Re: Org and Hyperbole

Re: Org and Hyperbole

[Robert Weiner]

Hi:

Thanks to Juan for starting this thread and the interesting
conversation it has started.  I just joined this mail list, so I don't
have the prior messages and can't reply to the thread, so I have
started this new one.

I am the author of Hyperbole and would be happy to answer questions
concerning Hyperbole today (so you don't have to answer based on
experience from the 1990s).  Hyperbole has been modernized for use
with Org mode and Emacs 28 and continues to develop.  There are videos
that demonstrate some of its features in simple, understandable ways.
Hyperbole is a single Emacs package that can be installed and
uninstalled quickly for testing.  It is largely a global minor mode,
so you can also disable it quickly if you ever care to.  In 20 minutes
you can get through the builtin, interactive demo and be on your way
to basic yet powerful usage.  We have listened to much feedback in the
last few years and made it much more approachable.

I find most of the confusion is people trying to understand how
Hyperbole works under the covers rather than just following the
tutorial and exploring it.  Hyperbole can be hacked on if you are a
moderate to advanced programmer but it is meant to be used, like Org
mode.  Hyperbole recognizes many, many common contexts in buffers that
could serve as hyperlinks (paths, URLs, multiple key sequences, mail
addresses, and on and on) and performs the typically desired action
when you press its Action Key {M-RET} on these 'implicit buttons'.
You get all this for free with no effort on your part.  Then if you
want to extend such behavior, as you have seen a bit of, you can
define your own implicit button and action types once and then
activate an infinite number of matching implicit buttons.  For
example, in an Emacs shell buffer, type:

   echo $PATH

then press the {M-RET} key or Shift-Middle mouse button on any path
there and jump right to it.  I find that very useful as a simple
example.  People are often surprised at how many things simply work
right out of the box because such broad context-sensitive behavior is
difficult to develop and rarely seen.  Just try it out and you should
find some contexts that you can leverage rapidly.  {C-h A} displays
what Hyperbole's Action Key will do in any context so you can always
check and learn before activating anything.  We say: Hyperbole brings
your text to life.  Like Org and Emacs, it provides an extensive
environment that you can grow into across time, getting ever more
productive rather than hitting a ceiling as with most point
packages/tools.

I am happy to answer questions and discuss ways we can make Hyperbole
and Org work even better together; one direct question per message
would typically work best.  Responses may take awhile as my schedule
makes it difficult to keep up with high volume mailing lists but if
you cc: rsw@gnu.org, I'll likely see your message faster and respond.

Re: Org and Hyperbole

[Robert Weiner]

[-- Attachment #1: Type: text/plain, Size: 485 bytes --]

For reference:

Hyperbole Videos are here:
   https://www.youtube.com/channel/UCNRwswKKpjOlOVfFTS73P9A/videos

The Hyperbole Home Page is here:
 https://www.gnu.org/software/hyperbole/

Just to look at if you don't want to interact with it,
the Hyperbole FAST-DEMO file is here:
  https://www.gnu.org/software/hyperbole/FAST-DEMO

The full web-version of the Hyperbole reference manual
(somewhat technical) is here:
   https://www.gnu.org/software/hyperbole/man/hyperbole.html

Enjoy.

[-- Attachment #2: Type: text/html, Size: 1764 bytes --]

Re: Org and Hyperbole

[Samuel Wales]

hi robert, welcome to the org list and thanks for your offer.

for starters, does hyperbole have any concept of links that are:

- unbreakable [like org-id]

- bidirectional [link a goes to link b; link b goes to link a], or,
reversible via command to say "what links here?" [by any mechanism.
if desired, please see "id markers" concept on this list for
unbreakable bidirectional links and more stuff]

On 6/23/22, Robert Weiner <rsw@gnu.org> wrote:
> For reference:
>
> Hyperbole Videos are here:
>    https://www.youtube.com/channel/UCNRwswKKpjOlOVfFTS73P9A/videos
>
> The Hyperbole Home Page is here:
>  https://www.gnu.org/software/hyperbole/
>
> Just to look at if you don't want to interact with it,
> the Hyperbole FAST-DEMO file is here:
>   https://www.gnu.org/software/hyperbole/FAST-DEMO
>
> The full web-version of the Hyperbole reference manual
> (somewhat technical) is here:
>    https://www.gnu.org/software/hyperbole/man/hyperbole.html
>
> Enjoy.
>


-- 
The Kafka Pandemic

A blog about science, health, human rights, and misopathy:
https://thekafkapandemic.blogspot.com

Re: Org and Hyperbole

[Robert Weiner]

Hi Samuel:

> On Jun 24, 2022, at 12:32 AM, Samuel Wales <samologist@gmail.com> wrote:
> 
> hi robert, welcome to the org list and thanks for your offer.
> 
> for starters, does hyperbole have any concept of links that are:
> 
> - unbreakable [like org-id]

This one is not so simple to answer.  Hyperbole only uses perma-hyperlink anchors in its Koutliner format.  But it would be straightforward to add a UUID-type id for use elsewhere.
> 
> - bidirectional [link a goes to link b; link b goes to link a], or,
> reversible via command to say "what links here?" [by any mechanism.
> if desired, please see "id markers" concept on this list for
> unbreakable bidirectional links and more stuff]

Hyperbole does not have bi-directional links, only a history function to move back through followed node paths.  We have started thinking about this need recently.

— rsw

Re: Org and Hyperbole

[indieterminacy]

Hi Robert,

On 24-06-2022 07:34, Robert Weiner wrote:
> Hi Samuel:
> 
>> On Jun 24, 2022, at 12:32 AM, Samuel Wales <samologist@gmail.com> 
>> wrote:
>> 
>> hi robert, welcome to the org list and thanks for your offer.
>> 
>> for starters, does hyperbole have any concept of links that are:
>> 
>> - unbreakable [like org-id]
> 
> This one is not so simple to answer.  Hyperbole only uses
> perma-hyperlink anchors in its Koutliner format.  But it would be
> straightforward to add a UUID-type id for use elsewhere.
>> 
>> - bidirectional [link a goes to link b; link b goes to link a], or,
>> reversible via command to say "what links here?" [by any mechanism.
>> if desired, please see "id markers" concept on this list for
>> unbreakable bidirectional links and more stuff]
> 
> Hyperbole does not have bi-directional links, only a history function
> to move back through followed node paths.  We have started thinking
> about this need recently.
> 
> — rsw
Improvements to the backend of Koutliner would be useful, especially as 
(if I recall from the documentation) the API aspects are not so clearly 
defined.

Bi-directionality would be a priority IMHO, especially to facilitate the 
updating of all links targeting a specific block should it move.

At the moment, each link self updates when it identifies a reference 
which needs to be updated but that comes across as an expediency (which 
I mitigate with direty look running through links to validate they are 
functional).

It would be great to achieve this with an 'eventual-consistency' type 
way, given that files could come in and out of a system or network.

Similarly, allowing the perma-hyperlink anchors to be transferred would 
really mature the format.

Here are some umble functions I use to facilitate moving blocks into 
other files:
https://git.sr.ht/~indieterminacy/1q20bwb_oq_transferring_emacs/tree/main/item/kqk_kq_blocks_koutliner.el

They at least avoid being descructive, as after moving the block becomes 
a pointer to where the moved block ended up in the other dcoument - but 
it feels like a fudge which could turn some documents into spaghetti.


While Im sure that you are planning on solving these problems within 
eLisp, I should point out that I shall have a Koutliner parser, written 
in TXR (soon to be finalised, Ive had some familial and health 
impedencies recently).

Here is a WIP
https://git.sr.ht/~indieterminacy/1q20hqh_oqo_parsing_glean

And a (rough) example
https://git.sr.ht/~indieterminacy/1q20hqh_oqo_parsing_glean#examples

I do need to add some facets (I suspect the linking for other blocks is 
in a seperate script).
I shall also be integrating the parser with GemText (Orgmode would be 
nice one day too).
https://git.sr.ht/~indieterminacy/1q20hqh_kq_parsing_gemtext/

I do quite like TXR's datalisp format but I havent gotten around to 
finding a way to slurping it up into eLisp. I feel like it should be 
easy to resolve but its not a query which is easy given SEO search.

The way Ill be approaching this interpreter is that it could search the 
aggregate or a journey from one document. Being able to have an overview 
of multiple documents is something I consider to be helpful, given the 
domain of cross-referencing.

and FYI, I will be working on outputting RDF from Koutliner and GemText 
analyses.

-- 
Jonathan McHugh
indieterminacy@libre.brussels

Re: Org and Hyperbole

[Robert Weiner]

[-- Attachment #1: Type: text/plain, Size: 4453 bytes --]

Hi Jonathan:

Yes, the backlink issue is one of the reasons we have not focused on moving
kcells with permanent hyperlink anchors from one file to another.  We
generally feel that the context of kcells within an outline is important
and thus should stay as a unit.  You obviously can and do link to any kcell
from outside the outline by combining the file path with the cell's
permanent id and thus could have a grep-like search across any number of
Koutlines.

But I agree a cross-file permanent ID structure could be useful and that
there are times where you want to move or copy outline structure between
files (we already support exporting the text of koutlines to other buffers
or to HTML), so this is a future use case to consider.

-- rsw


On Fri, Jun 24, 2022 at 6:55 AM indieterminacy
<indieterminacy@libre.brussels> wrote:

> Hi Robert,
>
> On 24-06-2022 07:34, Robert Weiner wrote:
> > Hi Samuel:
> >
> >> On Jun 24, 2022, at 12:32 AM, Samuel Wales <samologist@gmail.com>
> >> wrote:
> >>
> >> hi robert, welcome to the org list and thanks for your offer.
> >>
> >> for starters, does hyperbole have any concept of links that are:
> >>
> >> - unbreakable [like org-id]
> >
> > This one is not so simple to answer.  Hyperbole only uses
> > perma-hyperlink anchors in its Koutliner format.  But it would be
> > straightforward to add a UUID-type id for use elsewhere.
> >>
> >> - bidirectional [link a goes to link b; link b goes to link a], or,
> >> reversible via command to say "what links here?" [by any mechanism.
> >> if desired, please see "id markers" concept on this list for
> >> unbreakable bidirectional links and more stuff]
> >
> > Hyperbole does not have bi-directional links, only a history function
> > to move back through followed node paths.  We have started thinking
> > about this need recently.
> >
> > — rsw
> Improvements to the backend of Koutliner would be useful, especially as
> (if I recall from the documentation) the API aspects are not so clearly
> defined.
>
> Bi-directionality would be a priority IMHO, especially to facilitate the
> updating of all links targeting a specific block should it move.
>
> At the moment, each link self updates when it identifies a reference
> which needs to be updated but that comes across as an expediency (which
> I mitigate with direty look running through links to validate they are
> functional).
>
> It would be great to achieve this with an 'eventual-consistency' type
> way, given that files could come in and out of a system or network.
>
> Similarly, allowing the perma-hyperlink anchors to be transferred would
> really mature the format.
>
> Here are some umble functions I use to facilitate moving blocks into
> other files:
>
> https://git.sr.ht/~indieterminacy/1q20bwb_oq_transferring_emacs/tree/main/item/kqk_kq_blocks_koutliner.el
>
> They at least avoid being descructive, as after moving the block becomes
> a pointer to where the moved block ended up in the other dcoument - but
> it feels like a fudge which could turn some documents into spaghetti.
>
>
> While Im sure that you are planning on solving these problems within
> eLisp, I should point out that I shall have a Koutliner parser, written
> in TXR (soon to be finalised, Ive had some familial and health
> impedencies recently).
>
> Here is a WIP
> https://git.sr.ht/~indieterminacy/1q20hqh_oqo_parsing_glean
>
> And a (rough) example
> https://git.sr.ht/~indieterminacy/1q20hqh_oqo_parsing_glean#examples
>
> I do need to add some facets (I suspect the linking for other blocks is
> in a seperate script).
> I shall also be integrating the parser with GemText (Orgmode would be
> nice one day too).
> https://git.sr.ht/~indieterminacy/1q20hqh_kq_parsing_gemtext/
>
> I do quite like TXR's datalisp format but I havent gotten around to
> finding a way to slurping it up into eLisp. I feel like it should be
> easy to resolve but its not a query which is easy given SEO search.
>
> The way Ill be approaching this interpreter is that it could search the
> aggregate or a journey from one document. Being able to have an overview
> of multiple documents is something I consider to be helpful, given the
> domain of cross-referencing.
>
> and FYI, I will be working on outputting RDF from Koutliner and GemText
> analyses.
>
> --
> Jonathan McHugh
> indieterminacy@libre.brussels
>

[-- Attachment #2: Type: text/html, Size: 6184 bytes --]

Re: Org and Hyperbole

[Robert Weiner]

[-- Attachment #1: Type: text/plain, Size: 5227 bytes --]

Hi Jonathan:

I and I think others would love to understand what you are trying to
achieve.  I get that you want to use the Koutline format with external
systems like GemText and the TXR parser generator/Lisp language but I would
rather understand the purpose of what you are trying to build (problem(s)
to solve) and what you can't do with the Koutliner as it now stands that
you would like to do.  Try to explain it without referencing any particular
technologies, as I can't follow many of the things you write because of a
lack of context.

Thanks,

-- rsw

On Fri, Jun 24, 2022 at 8:51 AM Robert Weiner <rsw@gnu.org> wrote:

> Hi Jonathan:
>
> Yes, the backlink issue is one of the reasons we have not focused on
> moving kcells with permanent hyperlink anchors from one file to another.
> We generally feel that the context of kcells within an outline is important
> and thus should stay as a unit.  You obviously can and do link to any kcell
> from outside the outline by combining the file path with the cell's
> permanent id and thus could have a grep-like search across any number of
> Koutlines.
>
> But I agree a cross-file permanent ID structure could be useful and that
> there are times where you want to move or copy outline structure between
> files (we already support exporting the text of koutlines to other buffers
> or to HTML), so this is a future use case to consider.
>
> -- rsw
>
>
> On Fri, Jun 24, 2022 at 6:55 AM indieterminacy
> <indieterminacy@libre.brussels> wrote:
>
>> Hi Robert,
>>
>> On 24-06-2022 07:34, Robert Weiner wrote:
>> > Hi Samuel:
>> >
>> >> On Jun 24, 2022, at 12:32 AM, Samuel Wales <samologist@gmail.com>
>> >> wrote:
>> >>
>> >> hi robert, welcome to the org list and thanks for your offer.
>> >>
>> >> for starters, does hyperbole have any concept of links that are:
>> >>
>> >> - unbreakable [like org-id]
>> >
>> > This one is not so simple to answer.  Hyperbole only uses
>> > perma-hyperlink anchors in its Koutliner format.  But it would be
>> > straightforward to add a UUID-type id for use elsewhere.
>> >>
>> >> - bidirectional [link a goes to link b; link b goes to link a], or,
>> >> reversible via command to say "what links here?" [by any mechanism.
>> >> if desired, please see "id markers" concept on this list for
>> >> unbreakable bidirectional links and more stuff]
>> >
>> > Hyperbole does not have bi-directional links, only a history function
>> > to move back through followed node paths.  We have started thinking
>> > about this need recently.
>> >
>> > — rsw
>> Improvements to the backend of Koutliner would be useful, especially as
>> (if I recall from the documentation) the API aspects are not so clearly
>> defined.
>>
>> Bi-directionality would be a priority IMHO, especially to facilitate the
>> updating of all links targeting a specific block should it move.
>>
>> At the moment, each link self updates when it identifies a reference
>> which needs to be updated but that comes across as an expediency (which
>> I mitigate with direty look running through links to validate they are
>> functional).
>>
>> It would be great to achieve this with an 'eventual-consistency' type
>> way, given that files could come in and out of a system or network.
>>
>> Similarly, allowing the perma-hyperlink anchors to be transferred would
>> really mature the format.
>>
>> Here are some umble functions I use to facilitate moving blocks into
>> other files:
>>
>> https://git.sr.ht/~indieterminacy/1q20bwb_oq_transferring_emacs/tree/main/item/kqk_kq_blocks_koutliner.el
>>
>> They at least avoid being descructive, as after moving the block becomes
>> a pointer to where the moved block ended up in the other dcoument - but
>> it feels like a fudge which could turn some documents into spaghetti.
>>
>>
>> While Im sure that you are planning on solving these problems within
>> eLisp, I should point out that I shall have a Koutliner parser, written
>> in TXR (soon to be finalised, Ive had some familial and health
>> impedencies recently).
>>
>> Here is a WIP
>> https://git.sr.ht/~indieterminacy/1q20hqh_oqo_parsing_glean
>>
>> And a (rough) example
>> https://git.sr.ht/~indieterminacy/1q20hqh_oqo_parsing_glean#examples
>>
>> I do need to add some facets (I suspect the linking for other blocks is
>> in a seperate script).
>> I shall also be integrating the parser with GemText (Orgmode would be
>> nice one day too).
>> https://git.sr.ht/~indieterminacy/1q20hqh_kq_parsing_gemtext/
>>
>> I do quite like TXR's datalisp format but I havent gotten around to
>> finding a way to slurping it up into eLisp. I feel like it should be
>> easy to resolve but its not a query which is easy given SEO search.
>>
>> The way Ill be approaching this interpreter is that it could search the
>> aggregate or a journey from one document. Being able to have an overview
>> of multiple documents is something I consider to be helpful, given the
>> domain of cross-referencing.
>>
>> and FYI, I will be working on outputting RDF from Koutliner and GemText
>> analyses.
>>
>> --
>> Jonathan McHugh
>> indieterminacy@libre.brussels
>>
>

[-- Attachment #2: Type: text/html, Size: 7530 bytes --]

Re: Org and Hyperbole

[indieterminacy]

Hello Robert,

On 08-10-2022 22:26, Robert Weiner wrote:
> Hi Jonathan:
> 
> I and I think others would love to understand what you are trying to
> achieve.  I get that you want to use the Koutline format with external
> systems like GemText and the TXR parser generator/Lisp language but I
> would rather understand the purpose of what you are trying to build
> (problem(s) to solve) and what you can't do with the Koutliner as it
> now stands that you would like to do.  Try to explain it without
> referencing any particular technologies, as I can't follow many of the
> things you write because of a lack of context.
> 

How does one describe crimson and clover?

My medium term plans are to adapt my utilitarian setup, so that it 
becomes encapsulated.
Im planning to provide augmentation of Icebreaker's stack into areas of:
* text-to-speech
* speech-to-text
* braile

Though initially focusing on software design, I could (eventually) see 
advantages of product design to
complement the interfacing and interpreting aspects of my work.

Not technologically speaking, the problem Im wrestling is broadly 
similar to George Bernard Shaw (with regards to
notation; shorthand; and semiotics) when he proposed the Shavian 
Alphabet to supplant the
Latin alphabet.

Philologists should track down the later half of his preface in the 
book,
The Miraculous Birth of Language:
https://archive.org/details/in.ernet.dli.2015.462145/page/n9/mode/2up

Coincidentally, both his and my approaches to our different problems 
settled on a notation with 40 characters.


Focusing on my TXR interpreter, I have been creating my own flavour of 
canonical s-exp, Qiuynonical:
https://git.sr.ht/~indieterminacy/1q20hqh_oqo_parsing_qiuynonical

Here is an example of the parsing-expression-grammars interleaving 
different uris and there comments:
```
+ (("2:=>" "1: ") ("w-i" (("6:gemini" "3:://" "10:icebreaker" "1:." 
"5:space") ("5:/?q=/" ("3:111:1:." "1:+" "6:gemini" "3:://" 
"10:icebreaker" "1:." "5:space")))
+                  "i-w" ("3:REM:5:bunch:2:of:5:words" ("3:ueu" ("1:_" 
"14:testing-search"))))
+  "bing-x-b-ii-a")
+ (("2:=>" "1: ") ("w-i" (("6:gopher" "3:://" "10:icebreaker" "1:." 
"5:space") ("3:/?=" ("3:1aa:1:." "1:&" "6:gemini" "3:://" 
"10:icebreaker" "1:." "5:space")))
+                  "i-w" ("3:REM:5:bunch:2:of:5:words" ("3:ueu" ("1:_" 
"14:testing-search"))))
+  "bing-x-b-ii-a")
+ (("2:=>" "1: ") ("w-i" (("6:finger" "3:://" "10:icebreaker" "1:." 
"5:space") ("2:/?" ("3:1a2:1:." "1:&" "6:gemini" "3:://" "10:icebreaker" 
"1:." "5:space")))
+                  "i-w" ("3:REM:5:bunch:2:of:5:words" ("3:ueu" ("1:_" 
"14:testing-search"))))
+  "bing-x-b-ii-a")
+ (("2:=>" "1: ") ("w-i" (("5:https:5:bunch:2:of:5:words" "3:://" 
"10:icebreaker" "1:." "5:space") ("4:/?q=" ("2:1a:1:." "1:%" "6:gemini" 
"3:://" "10:icebreaker" "1:." "5:space")))
+                  "i-w" ("3:REM" ("3:ueu" ("1:_" 
"14:testing-search"))))
+  "bing-x-b-ii-a")
```

Notice how "REM" is actually the first instance of non official token, 
starting a new parenthesis but still permitting repetitive patterns for 
things like "ueu" as an annotation to still be caught later on (with or 
without descriptors (which could be an underline, a tab or two or more 
whitespaces).

Niceley, the way ive been approaching breakpoints between line-types and 
content-types is that you could(!) have iterating blocks of gemtext and 
koutliner within the same line - with the datalisp representing it as an 
array.

As a consequence, one may then use logic rules for sophisticated 
inferences.
Such as querying a subtext of a gemtext document and appending a 
conclusion or requirement in a referenced koutliner block.

Think YahooPipes for playgrounding.


In terms of accessibility, rather than all content being read out, uris 
could be counted and headers or notion read out with a distinctive tone.
Or similarly, concerning annotations or dates.



It is of course worth stating that gemtext has advantages for written 
prose, especially its ease of transmission with its TLS backed protocol, 
Gemini.
I appreciate its simplicity and minimalism, including on a technical and 
tooling level.

Here is a (recently released) video from last years Software Freedom Day 
concerning Gemini and complexity:
https://www.youtube.com/watch?v=zyTC4QWGCQg

FFIW, the messaging service featured in the talk used sqlite.

I feel that Gemtext is as worthy of usage as Outline for instance and 
the cost for interoperating with Orgmode not insurmountable.

It is worth stating that I treat all coding comments as the 
aforementioned formats and syntaxes.
With the intention of inverting code documents into a 
literate-programming form.

Given that out of the box TXR can operate inside a Gemtext document and 
output something different gemtext content makes me feel that
  there are a lot of possibilities yet to explore.


This quote from the Gemini community highlights why Icebreaker feels it 
is making the correct design decisions (given the importance of Gemtext 
to its technology stack):
```
I am a blind person who is interested in all kinds of different ways of 
working with text and writing.
I’ve written in Markdown, Org-mode, tried LaTex but found it just about 
as verbose to write as HTML,
and thought about Restructured Text but the advanced stuff in it looked 
a lot like HTML too.
Anyways, I got into Gemini because of the simplicity.

I loved the idea of basically a Markup language being the pure writing 
method of an entire site.
No static site generator needed, just directories of linked plain text 
files.
No CSS, no JavaScript, no Liquid or or shortcakes or anything.
...
Screen readers are not smart.
They speak whatever the operating system or application exposes to the 
accessibility API’s.
Sure, the spoken, or brailled, output can be arranged or massaged 
slightly,
but whatever is there is what will be spoken, from left to right, top to 
bottom.

Some screen readers, like NVDA and JAWS, and Orca to some extent,
do try to massage the data of websites to make them easier to use or to 
fix accessibility issues that
the web developer won’t or can’t, but there’s a line they try not to 
cross between scripting things to
work better and making up a whole new interface for something when the 
UI developers don’t consider accessibility.
Even if the block is labeled, it’s still text, and the screen reader 
will do what it does, read all of it.
...
Now, this isn’t to say that Gemini is bad for accessibility. I love 
being able to get right to the content of
a page *quickly* because there are no sidebars, no top navigation links, 
no ads, no frames, no nonsense.
It’s like having the whole web in reader view, with only useful or 
important links at the bottom or
somewhere out of the way. I *love* that about Gemini,
and it’s why I read it on not only my laptop with Emacs, but on my 
iPhone too.
So thank you all for this great way to read and write on the Internet!
```
https://lists.orbitalfox.eu/archives/gemini/2021/005631.html [Clients] 
Gemini and accessibility regarding preformatted code blocks
(an archived citation from a retired mailinglist)

> 
> On Fri, Jun 24, 2022 at 8:51 AM Robert Weiner <rsw@gnu.org> wrote:
> 
>> Hi Jonathan:
>> 
>> Yes, the backlink issue is one of the reasons we have not focused on
>> moving kcells with permanent hyperlink anchors from one file to
>> another.  We generally feel that the context of kcells within an
>> outline is important and thus should stay as a unit.  You obviously
>> can and do link to any kcell from outside the outline by combining
>> the file path with the cell's permanent id and thus could have a
>> grep-like search across any number of Koutlines.
>> 
>> But I agree a cross-file permanent ID structure could be useful and
>> that there are times where you want to move or copy outline
>> structure between files (we already support exporting the text of
>> koutlines to other buffers or to HTML), so this is a future use case
>> to consider.
>> 
>> -- rsw

Ive decided to chunk blocks of text as a mechanism to cross-manage my 
knowledge assets

Im electing to use an awk parser to do an earlier pass and divide 
(gemtext and koutliner)
  documents into chunks (according to headers or blocks).

  
https://git.sr.ht/~indieterminacy/1q20hqh_kq-owo_interpreting_gemtext-glint

 From the chunks hashes shall be made, including of:
*    canonical s-exps
*    datalisps (formed from Qiuynonical)
*    third party formats (orgmode; latex; scribillo

These chunks and interpretations shall form individual files, to be 
cross referenced using the token database, ldif.
I understand that ldif plays nicely with emacs.

The current plans are for ldif for funneling issues and troubleshooting.

It should be Gemtext friendly but an inversion of the considered 
syntaxes (expessed here in a TXR form):

```
> # @nw-ue_mq-te_sequence_any-header@;; 
> iw-rw_heh-owo_found-during_parsing-involving-awk-too-glint
=> 
./mq-tet_raw/@xw-tet_mq-xw_w-te_hash-value-in-canonical-form@(os-2)@/\*#/@;; 
tet_mq-te_aggregate_body-with-header
=> ./mq-tet_raw/@xw-tet_mq-xw_w-te_hash-value-in-canonical-form@(os-2)@ 
\*/@;; tet_mq-te_constituent_body-without-header
=> 
./mq-te_canonical-s-exp/@xw-tet_mq-xw_w-te_hash-value-in-canonical-form@(os-2)@/\*#/@;; 
tet_mq-te_aggregate_body-with-header
=> 
./mq-te_canonical-s-exp/@xw-tet_mq-xw_w-te_hash-value-in-canonical-form@(os-2)@ 
\*/@;; tet_mq-te_constituent_body-without-header
@(maybe)
@(cases)
=> 
./mq-mqm_qiuynonical/@xw-tet_mq-xw_w-te_hash-value-in-canonical-form@(os-2)@/\*#/@;; 
tet_mq-te_aggregate_body-with-header
=> 
./mq-mqm_qiuynonical/@xw-tet_mq-xw_w-te_hash-value-in-canonical-form@(os-2)@ 
\*/@;; tet_mq-te_constituent_body-without-header
@(or)
=> 
./mq-tet_raw/@xw-tet_mq-xw_w-te_hash-value-in-canonical-form@(os-2)@/\*##/@;; 
tet_mq-te_aggregate_body-with-header
=> ./mq-tet_raw/@xw-tet_mq-xw_w-te_hash-value-in-canonical-form@(os-2)@ 
\*/@;; tet_mq-te_constituent_body-without-header
=> 
./mq-te_canonical-s-exp/@xw-tet_mq-xw_w-te_hash-value-in-canonical-form@(os-2)@/\*##/@;; 
tet_mq-te_aggregate_body-with-header
=> 
./mq-te_canonical-s-exp/@xw-tet_mq-xw_w-te_hash-value-in-canonical-form@(os-2)@ 
\*/@;; tet_mq-te_constituent_body-without-header
=> 
./mq-mqm_qiuynonical/@xw-tet_mq-xw_w-te_hash-value-in-canonical-form@(os-2)@/\*##/@;; 
tet_mq-te_aggregate_body-with-header
=> 
./mq-mqm_qiuynonical/@xw-tet_mq-xw_w-te_hash-value-in-canonical-form@(os-2)@ 
\*/@;; tet_mq-te_constituent_body-without-header
@(maybe)
...
@(end)
@(or)
...
@(end)
@(end)
```

This tree approach allows search utilities to get an overriding 
impression of a document and how it interleaves with other documents and 
project environments.

I feel it should give an idea as to how an knowledge ecosystem is 
changing over time, especially if contexts are provided in git messages 
for this hashing technique.

Hopefully it can encourage users to have greater granularity.
I feel that it will be useful covering my extremely wide and flat folder 
structure within my system.
Ultimately, I want to track concepts as they move within documents and 
across filetypes.

If you want to see an example of how gemtext and git integrate nicely 
with respect to task-management I encourage you to visit this Guile 
project:
https://github.com/genenetwork/gn-gemtext-threads




Qiuy is a knowledge and interface orientated solution for Semantic 
Business Process Management (SBPM) type concerns:

*    It uses notation that has the same physical patterns that are used 
by any user requiring
     the use of modifying keys to command things quickly
*    Qiuy is not constrained by being contained within one tool, one 
language or one format
     (let alone languishing in logfiles).
*    Its notation serves as a universal prefix, which is front and 
present, terse and proud - permitting people to autonomously
     augment according to need, toolsets and context.
*    As such, it is not a destination point in itself - rather a means 
to an end to reach a goal in the quickest and most succinct way.
*    A direct consequence of this is that recall and interaction can be 
managed according to tactical criteria
     (such as repeatability; signalling; extensibility; or scope)

As such, Qiuy is beneficial for domains such as identifying other 
semantic modelling constructs within or across collections
(for say drilling down or across collections such as RDF constructs), or 
providing entrypoints for integrating information assets
from alternative linguistic languages (such as Lojban); syntaxes; or 
formats.

Predicated on putting explanations and expectations into chunks,
Qiuy is a mechanism for description; interpretation; interfacing; and 
change -
recursively, whether in imperative; declarative; or functional forms.


Below are examples concerning Qiuy's graph orientated approach to 
taxonomies and ontologies.

So for instance for search criteria:

a policy on tasks:
iw-rqr

a task concerning internal-policy:
rqr-iw

an observed task concerning third-party-policy on the topic of 
running-events:
rer-ie_rqr-iwi

completing a policy-position around parsing-results
rwr-iw_hwh

These annotation sets of 40 (36 (single or repeated letter) archtypes 
and four for direction and/or normative and positive demarcations)
Two annotations combined creates a permutative range of below 17k 
combinations.
Im often writing with 4 annotations in combination with differing types 
of delimeters and descriptions
(with the weighting of the stack to aid handpicking subsets).

There are few clashes with these notations with conventional texts and 
coding.
The discipline has more of an improvisary and fuzzy quality to it, as if 
the initial pathway to something isnt immediately
  found there are enough workflows and heuristics to find something (if 
not reevaluate).

As such, from the perspective of metaphysics it is operating as 
something more akin to body-language.
Or from a scientific management, something like Pitman shorthand.

Im sure you can appreciate how Hyperbole's context aware actions can be 
potent for identifying and acting upon these annotations.


In relation to databases, the value of having an interpreter for 
representing Qiuy annotations will be significant.
This is because that database will be able to grep whitespace delimeters 
in used within queries for annotations or annotations.
Otherwise, only full capture when using '-' or '_' delimeters.

I find my Qiuy annotations, they are similar length but terser than 
shorthands or triads.
I increasingly use triads as a technique to delineate between 
descriptors using these annotations.

Heres this primer on the types of annotations and how they operate 
within a filesystem:
https://10years.guix.gnu.org/video/l-union-qiuy-fait-la-force/

In essence, Im trying to represent a universal prefix to serve as a mid 
semantic point notation - within and across systems.

You might appreciate how encapsulating is advantageous from a cognitive 
as well as an accessibility viewpoint.

These tooling environments combined in an emacs environment permit me to 
really move across a filesystem rapidly and switch contexts casually.

The proliferation of my annotations across content and coding give me a 
sophistication that grows capacities unimpeded.

If you visit these logs you may get a better idea regarding how I use 
these annotations are used for managing a project:
https://git.sr.ht/~indieterminacy/1q20hqh_oqo_parsing_qiuynonical/log

Fwiw, I started writing a book on Qiuy, though it covers the topic from 
a more artistic perspective and is now a couple of years old:
https://matrix.to/#/!moDjfUaAGUFxVySkEd:matrix.org/$SOThirF1w3DwXQxIg56Anu5vjztoT1R99ClWzqxKuJY?via=matrix.org&via=kernelpanic.cafe


HTH!

When Im not yak-shaving I can be found here considering such topic areas
https://matrix.to/#/#xq_icebreaker:matrix.org


>> 
>> On Fri, Jun 24, 2022 at 6:55 AM indieterminacy
>> <indieterminacy@libre.brussels> wrote:
>> 
>>> Hi Robert,
>>> 
>>> On 24-06-2022 07:34, Robert Weiner wrote:
>>>> Hi Samuel:
>>>> 
>>>>> On Jun 24, 2022, at 12:32 AM, Samuel Wales
>>> <samologist@gmail.com>
>>>>> wrote:
>>>>> 
>>>>> for starters, does hyperbole have any concept of links that
>>> are:
>>>>> 
>>>>> - unbreakable [like org-id]
>>>> 
>>>> This one is not so simple to answer.  Hyperbole only uses
>>>> perma-hyperlink anchors in its Koutliner format.  But it would
>>> be
>>>> straightforward to add a UUID-type id for use elsewhere.
>>>>> 
>>>>> - bidirectional [link a goes to link b; link b goes to link a],
>>> or,
>>>>> reversible via command to say "what links here?" [by any
>>> mechanism.
>>>>> if desired, please see "id markers" concept on this list for
>>>>> unbreakable bidirectional links and more stuff]
>>>> 
>>>> Hyperbole does not have bi-directional links, only a history
>>> function
>>>> to move back through followed node paths.  We have started
>>> thinking
>>>> about this need recently.
>>>> 
>>>> — rsw
>>> Improvements to the backend of Koutliner would be useful,
>>> especially as
>>> (if I recall from the documentation) the API aspects are not so
>>> clearly
>>> defined.
>>> 
>>> Bi-directionality would be a priority IMHO, especially to
>>> facilitate the
>>> updating of all links targeting a specific block should it move.
>>> 
>>> At the moment, each link self updates when it identifies a
>>> reference
>>> which needs to be updated but that comes across as an expediency
>>> (which
>>> I mitigate with direty look running through links to validate they
>>> are
>>> functional).
>>> 
>>> It would be great to achieve this with an 'eventual-consistency'
>>> type
>>> way, given that files could come in and out of a system or
>>> network.
>>> 
>>> Similarly, allowing the perma-hyperlink anchors to be transferred
>>> would
>>> really mature the format.
>>> 
>>> Here are some umble functions I use to facilitate moving blocks
>>> into
>>> other files:
>>> 
>> 
> https://git.sr.ht/~indieterminacy/1q20bwb_oq_transferring_emacs/tree/main/item/kqk_kq_blocks_koutliner.el
>>> 
>>> They at least avoid being descructive, as after moving the block
>>> becomes
>>> a pointer to where the moved block ended up in the other dcoument
>>> - but
>>> it feels like a fudge which could turn some documents into
>>> spaghetti.
>>> 
>>> While Im sure that you are planning on solving these problems
>>> within
>>> eLisp, I should point out that I shall have a Koutliner parser,
>>> written
>>> in TXR (soon to be finalised, Ive had some familial and health
>>> impedencies recently).
>>> 
>>> Here is a WIP
>>> https://git.sr.ht/~indieterminacy/1q20hqh_oqo_parsing_glean
>>> 
>>> And a (rough) example
>>> 
>> https://git.sr.ht/~indieterminacy/1q20hqh_oqo_parsing_glean#examples
>>> 
>>> I do need to add some facets (I suspect the linking for other
>>> blocks is
>>> in a seperate script).
>>> I shall also be integrating the parser with GemText (Orgmode would
>>> be
>>> nice one day too).
>>> https://git.sr.ht/~indieterminacy/1q20hqh_kq_parsing_gemtext/
>>> 
>>> I do quite like TXR's datalisp format but I havent gotten around
>>> to
>>> finding a way to slurping it up into eLisp. I feel like it should
>>> be
>>> easy to resolve but its not a query which is easy given SEO
>>> search.
>>> 
>>> The way Ill be approaching this interpreter is that it could
>>> search the
>>> aggregate or a journey from one document. Being able to have an
>>> overview
>>> of multiple documents is something I consider to be helpful, given
>>> the
>>> domain of cross-referencing.
>>> 
>>> and FYI, I will be working on outputting RDF from Koutliner and
>>> GemText
>>> analyses.
>>> 
>>> --
>>> Jonathan McHugh
>>> indieterminacy@libre.brussels

-- 
Jonathan McHugh
indieterminacy@libre.brussels

Re: Org and Hyperbole

[Jean Louis]

* Robert Weiner <rswgnu@gmail.com> [2022-06-24 12:53]:
> Hyperbole does not have bi-directional links, only a history
> function to move back through followed node paths.  We have started
> thinking about this need recently.

If at all it is useful.

As you know I am using database backed Dynamic Knowledge Repository
Hyperscope. It has hyobjects table, and there is hyobjectrelations
table that keeps track of related hyobjects.

The workflow to record back links for any document is following:

- all links have to be stored somewhere, so that they get their
  reference; with Emacs 29 and built-in SQLite database that could be
  one way to go. Other way is to keep stored values in files, and have
  for each link some UUID or similar.

- there must be table of relations or file containing relations, in
  such file one would record the file name where link was inserted,
  and the link's UUID;

- functions to insert links in any lightweight markup file would need
  to be rewritten so that they:

  1. Verify that link has got its reference, UUID or some other
     reference. That can work automatically. If I am inserting
     hyperlink such as "ABC" to file "/tmp/my-file.txt" with line
     number 3, then as soon as I have decided it, the function would
     insert it into the tracking file or database table;

  2. Function would also remember that file "/tmp/my-file.txt" has go
     the link "ABC", and would at least try to remember its line
     number or surrounding text. This information would be stored in
     backlinks file or backlinks table;

By using the above principle one could record backlinks, both in Org
mode or any other mode.

-- 
Jean

Take action in Free Software Foundation campaigns:
https://www.fsf.org/campaigns

In support of Richard M. Stallman
https://stallmansupport.org/

Re: Org and Hyperbole

[Robert Weiner]

[-- Attachment #1: Type: text/plain, Size: 2649 bytes --]

Thanks, Jean.  We have started work on a note-taking subsystem for
Hyperbole that will store UUIDs per note and will likely support backlinks
too.  We are seeing if we can make it support Koutlines, Emacs Outlines,
Org mode files and Markdown files, searching across all formats at the same
time.  The default for creating new notes will likely be a personal
Koutline file.

We welcome brief summaries of features you need for effective note taking
in Emacs.  We are not looking to do much with images or on mobile devices,
just focused on people who spend a lot of time in Emacs and want an
easy-to-use notes system that does not require any external packages like
SQLite.


On Tue, Sep 27, 2022 at 10:00 AM Jean Louis <bugs@gnu.support> wrote:

> * Robert Weiner <rswgnu@gmail.com> [2022-06-24 12:53]:
> > Hyperbole does not have bi-directional links, only a history
> > function to move back through followed node paths.  We have started
> > thinking about this need recently.
>
> If at all it is useful.
>
> As you know I am using database backed Dynamic Knowledge Repository
> Hyperscope. It has hyobjects table, and there is hyobjectrelations
> table that keeps track of related hyobjects.
>
> The workflow to record back links for any document is following:
>
> - all links have to be stored somewhere, so that they get their
>   reference; with Emacs 29 and built-in SQLite database that could be
>   one way to go. Other way is to keep stored values in files, and have
>   for each link some UUID or similar.
>
> - there must be table of relations or file containing relations, in
>   such file one would record the file name where link was inserted,
>   and the link's UUID;
>
> - functions to insert links in any lightweight markup file would need
>   to be rewritten so that they:
>
>   1. Verify that link has got its reference, UUID or some other
>      reference. That can work automatically. If I am inserting
>      hyperlink such as "ABC" to file "/tmp/my-file.txt" with line
>      number 3, then as soon as I have decided it, the function would
>      insert it into the tracking file or database table;
>
>   2. Function would also remember that file "/tmp/my-file.txt" has go
>      the link "ABC", and would at least try to remember its line
>      number or surrounding text. This information would be stored in
>      backlinks file or backlinks table;
>
> By using the above principle one could record backlinks, both in Org
> mode or any other mode.
>
> --
> Jean
>
> Take action in Free Software Foundation campaigns:
> https://www.fsf.org/campaigns
>
> In support of Richard M. Stallman
> https://stallmansupport.org/
>

[-- Attachment #2: Type: text/html, Size: 3636 bytes --]

Re: Org and Hyperbole

[David Masterson]

Robert Weiner <rsw@gnu.org> writes:

> We welcome brief summaries of features you need for effective note
> taking in Emacs.  We are not looking to do much with images or on
> mobile devices, just focused on people who spend a lot of time in
> Emacs and want an easy-to-use notes system that does not require any
> external packages like SQLite.

One major use-case for Org is capturing a task quickly.  This can be
done with Org or Mobile-Org (BeOrg, Orgzly).  One feature not easily
available is attaching images to the task to better explain the task.

Thoughts on this?

-- 
David Masterson

Re: Org and Hyperbole

[Jean Louis]

On October 4, 2022 6:05:58 PM UTC, David Masterson 
>One major use-case for Org is capturing a task quickly.  This can be
>done with Org or Mobile-Org (BeOrg, Orgzly).  One feature not easily
>available is attaching images to the task to better explain the task.
>
>Thoughts on this?

There are many ways of capturing elementary objects. Org Capture is one way as it's connection between Emacs and outside programs or Emacs and Emacs.

With or without Org or Emacs computer users should be able to capture any pieces of information and it's references in any type of a system.

For me personally I use PostgreSQL database and have finely grained types of objects, so I can relate anything to anything, then export to Org or package with any kind of connected objects, not only Org.

The way to go for Org users is to make a function that first takes specific files and then captures the rest. Then files are to be used as properties or links in subheading.

That is what I don't like as too many properties and markup is really disturbing. I keep it invisible.

Design of such system shall be that each elementary object has our get it's really unique reference, possibly across networks and world, then that it gets it's type of relation, and it's value such as file. The file is object too, must have it's references.

Relation could be just RELATED, but it could be, CONTRACT or DISREGARD, as one shall know why are some other objects attached.

Relating objects is most important in information management.

https://en.m.wikipedia.org/wiki/Relational_database

What you and many others really want is relational database. I see no problem to connect Org to such. You can have just one property like ID or embedded not presentable link and all other properties related through one, by principles of the relational database.

I often use preprocessing markup tags that interpolate to anything, like Org markup or any other. That way I can add just anything to Org or any other text. Like bunch of files or links, without using specific mode.

Feature I use mostly to inject single objects into bunch of files, even thousands of files. When I edit such single object, other files automatically interpolate the contents of such object.

Imagine company address appearing on thousands of related pages and over different domains, editing phone number changes it anywhere.

Imagine that link name changes each in na while like those links showing specific but dynamic market price, when price is changed all documents get the new link name without files being edited or modified.

When you have single object ID then adding files to it can be handled outside the single Org file. Imagine an Org ID as universal hyperlink to other objects. Let us say, properties in other file like "attachment" and list of files in that other file.

It is up to Org designers to better adopt the idea of decentralization of properties, tags, etc. One can't put all the messy looking stuff in text file, it's not text any more, it looks like garbage on the screen.

Moving more to the extreme then anything can be separated from Org and written in plethora of other modes, markups and then presented in the Org simple way for clarity and better understanding to final user.



Jean

Re: Org and Hyperbole

[Robert Weiner]

[-- Attachment #1: Type: text/plain, Size: 4707 bytes --]

We had object-based, multi-media files with Engelbart's NLS/Augment
system.  We had relational databases way before the web.

But here we are in 2022 with enormous personal computing power and for
interactive editing, everyone is using and transferring stream-based files
of characters that are then interpreted at the delivery site.  There are
many reasons for this including limits in many organizations of the file
types that may be transferred through common protocols and the difficulty
of maintaining relational database or structured file type schemas across
time.

Simple tends to win out over more powerful because few people want to bear
the cost of continual training to raise all of the newcomers to a level of
performance that they cannot teach themselves.

I like your model, Jean, and am a fan of such things but I am also
pragmatic and thus focus on building things that I think people will
consume within a given environment.  In Hyperbole's case, it is base Emacs
and nothing more.  If you are familiar with what it takes to standup a
scalable web application today (what everyone wants), you understand why
that is not a great model for systems where the users have to manage and
customize the infrastructure themselves.

-- rsw

On Fri, Oct 7, 2022 at 3:52 PM Jean Louis <bugs@gnu.support> wrote:

> On October 4, 2022 6:05:58 PM UTC, David Masterson
> >One major use-case for Org is capturing a task quickly.  This can be
> >done with Org or Mobile-Org (BeOrg, Orgzly).  One feature not easily
> >available is attaching images to the task to better explain the task.
> >
> >Thoughts on this?
>
> There are many ways of capturing elementary objects. Org Capture is one
> way as it's connection between Emacs and outside programs or Emacs and
> Emacs.
>
> With or without Org or Emacs computer users should be able to capture any
> pieces of information and it's references in any type of a system.
>
> For me personally I use PostgreSQL database and have finely grained types
> of objects, so I can relate anything to anything, then export to Org or
> package with any kind of connected objects, not only Org.
>
> The way to go for Org users is to make a function that first takes
> specific files and then captures the rest. Then files are to be used as
> properties or links in subheading.
>
> That is what I don't like as too many properties and markup is really
> disturbing. I keep it invisible.
>
> Design of such system shall be that each elementary object has our get
> it's really unique reference, possibly across networks and world, then that
> it gets it's type of relation, and it's value such as file. The file is
> object too, must have it's references.
>
> Relation could be just RELATED, but it could be, CONTRACT or DISREGARD, as
> one shall know why are some other objects attached.
>
> Relating objects is most important in information management.
>
> https://en.m.wikipedia.org/wiki/Relational_database
>
> What you and many others really want is relational database. I see no
> problem to connect Org to such. You can have just one property like ID or
> embedded not presentable link and all other properties related through one,
> by principles of the relational database.
>
> I often use preprocessing markup tags that interpolate to anything, like
> Org markup or any other. That way I can add just anything to Org or any
> other text. Like bunch of files or links, without using specific mode.
>
> Feature I use mostly to inject single objects into bunch of files, even
> thousands of files. When I edit such single object, other files
> automatically interpolate the contents of such object.
>
> Imagine company address appearing on thousands of related pages and over
> different domains, editing phone number changes it anywhere.
>
> Imagine that link name changes each in na while like those links showing
> specific but dynamic market price, when price is changed all documents get
> the new link name without files being edited or modified.
>
> When you have single object ID then adding files to it can be handled
> outside the single Org file. Imagine an Org ID as universal hyperlink to
> other objects. Let us say, properties in other file like "attachment" and
> list of files in that other file.
>
> It is up to Org designers to better adopt the idea of decentralization of
> properties, tags, etc. One can't put all the messy looking stuff in text
> file, it's not text any more, it looks like garbage on the screen.
>
> Moving more to the extreme then anything can be separated from Org and
> written in plethora of other modes, markups and then presented in the Org
> simple way for clarity and better understanding to final user.
>
>
>
> Jean
>

[-- Attachment #2: Type: text/html, Size: 5879 bytes --]

Re: Org and Hyperbole

[Jean Louis]

* Robert Weiner <rsw@gnu.org> [2022-10-09 00:06]:
> We had object-based, multi-media files with Engelbart's NLS/Augment
> system.  We had relational databases way before the web.
> 
> But here we are in 2022 with enormous personal computing power and for
> interactive editing, everyone is using and transferring stream-based files
> of characters that are then interpreted at the delivery site.

Alright, though I do not see relation from transferring files to
databases. Just any digital information may be transferred to delivery
sites by many different means. I understand that two paragraphs are
related and I inject my thoughts in maybe not proper place.

> There are many reasons for this including limits in many
> organizations of the file types that may be transferred through
> common protocols and the difficulty of maintaining relational
> database or structured file type schemas across time.

I can't see how relational database is more difficult to maintain then
for example Emacs itself. Emacs is master of difficulties for computer
user. For example I have not touched configuration files for
PostgreSQL since years, if not decades. I start wondering why.

Backing up relational database is so much easier than backing up
plethora of apparently randomly dispersed files. It is just single
command line or click on some graphical interface. Just do
`pg_dumpall'. 

Let us say I wish to backup all the information that Hyperbole created
in various directories, on computer, is there such option? Missing.

We can't compare apples and eggs, but I have to give you for thinking. 

Hyperbole buttons in their files are underlying structure, user need
not know anything about it. User has interface and uses higher level
interface functions.

But let us analyze it little that way. If you have a Hyrolo file, what
you can do with it? You can send it to somebody? But that somebody
need to use what? Emacs or any editor to work with contacts.

Today users use mobile devices, they exchange structured contact
information by using vCard format, and users of many mobile devices can
accept contact information from other operating systems and import in
their phones as one or multiple without problems.

Hyrolo can't transfer contact information. And why? Because it is
written more or less freely in the text file and it is not structured. 

We don't speak of maintaining Hyrolo -- that is not easy task really,
it needs GNU Emasc which has so many dependencies, then it needs
Hyperbole, then user can handle Hyrolo. What I want to say we shall
not think of complexities, issues of installation and underlying
management by software are not concern for user. User shall be able to
click and get application. That is what 50% of people using computers
know, they have mobile devices, they click and get it. No thinking
there, but I don't say it advances society that way.

In any relational databases there are views and various exports and
unlimited variations how final data may be presented to user.

Let us say contacts, that may be transferred by using vCard
mechanism. Various other formats are possible.

Let us say I need to exchange tasks, that is what I do all the
time. Nobody at delivery site need know that I have underlying
PostgreSQL database, that is not their business. They will get the
PDF, image, video, text, WWW link, ZIP, and similar. Delivery site
will get it delivered in the format how they can read it.

If delivery site needs full database, it is just matter of two
commands pg_dumpall and pg_restore and even those commands may be
automated.

Full database is similar to file system. One does not share file
system, one shares database entries. And how such entries are shared
depends of the programmer and user. Thousands of entries from my
database are shared through web server and as HTML documents. Program
generates PDF files and text, and emails for plans, programs and
projects, and such are shared by any type of communication channel.

> Simple tends to win out over more powerful because few people want to bear
> the cost of continual training to raise all of the newcomers to a level of
> performance that they cannot teach themselves.

Today people use structured information without knowing. Contacts on
phone are structured. Even notes' applications on mobile devices are
pretty much structured, usually stored in SQLited databases and
exported in various ways. Much of information in any libraries, online
databases, and personal computers is stored in such databases.

> I like your model, Jean, and am a fan of such things but I am also
> pragmatic and thus focus on building things that I think people will
> consume within a given environment.

In the Emacs environment we consume anything that is useful, it is
wide open. Emacs 29 comes with SQLite built-in. That is advance,
progress. 

We can progress all with databases.

>  In Hyperbole's case, it is base Emacs and nothing more.

Emacs alone has many ways to store ordered and structured
information.

> If you are familiar with what it takes to standup a scalable web
> application today (what everyone wants), you understand why that is
> not a great model for systems where the users have to manage and
> customize the infrastructure themselves.

I can't. 

What I think is that you never tried it out and did not understand
that database minimizes human efforts and errors. It minimizes our
efforts also because many functions you have programmed for Hyperbole
and many functions people do in Org are already built-in in the
database.

There are many various systems that use ordered information.

Example is Leo editor:

Leo programmable editor:
http://leoeditor.com/

Leo editor vs Org-mode:
https://leoeditor.com/emacs.html

I guess it fully uses database and thus it can handle ordered
information so much easier.

I have examined hyrolo-add function, it only adds a single name to the
file. And function is that huge.

Here is function that adds name, email and description in the simple database:

(defun my-people-add ()
  (interactive)
  (let* ((first-name (read-string "First name: "))
	 (middle-names (read-string "Middles names: "))
	 (name-or-last-name (let ((result))
			      (while (not result)
				(setq result (apply 'read-string '("Last name: "))))
			      result))
	 (email (read-string "Email: "))
	 (description (read-string "Description: ")))
    (sqlite-execute my-db "INSERT INTO people (people_firstname, people_middlenames, people_name, people_email, people_description)
                           VALUES (?, ?, ?, ?, ?) RETURNING people_id" 
		    (list first-name middle-names name-or-last-name description))))

And then we speak of internal and external complexities. But those are
subjective opinions.

What is objective is to see the how big is the code that handles
purely text (and never reaches the point of being deterministic) and
the size of code that handles equivalent functions using database.

-- 
Jean

Take action in Free Software Foundation campaigns:
https://www.fsf.org/campaigns

In support of Richard M. Stallman
https://stallmansupport.org/

Re: Org and Hyperbole

[David Masterson]

Jean Louis <bugs@gnu.support> writes:

> * Robert Weiner <rsw@gnu.org> [2022-10-09 00:06]:
>> There are many reasons for this including limits in many
>> organizations of the file types that may be transferred through
>> common protocols and the difficulty of maintaining relational
>> database or structured file type schemas across time.
>
> I can't see how relational database is more difficult to maintain then
> for example Emacs itself. Emacs is master of difficulties for computer
> user. For example I have not touched configuration files for
> PostgreSQL since years, if not decades. I start wondering why.

The issue here is distribution.  Databases tend to be centralized and
heavy weight.  Here, we're simply looking for a standard way to capture
an image (or more) with a task/note and tranport it back to your main
Org file (a la Org Mobile or ...).  Org is lightweight in this area
which is good and bad.

-- 
David Masterson

Re: Org and Hyperbole

[Jean Louis]

* David Masterson <dsmasterson@gmail.com> [2022-10-10 19:55]:
> Jean Louis <bugs@gnu.support> writes:
> 
> > * Robert Weiner <rsw@gnu.org> [2022-10-09 00:06]:
> >> There are many reasons for this including limits in many
> >> organizations of the file types that may be transferred through
> >> common protocols and the difficulty of maintaining relational
> >> database or structured file type schemas across time.
> >
> > I can't see how relational database is more difficult to maintain then
> > for example Emacs itself. Emacs is master of difficulties for computer
> > user. For example I have not touched configuration files for
> > PostgreSQL since years, if not decades. I start wondering why.
> 
> The issue here is distribution.  Databases tend to be centralized and
> heavy weight.

What does it mean centralized in this context? Majority of Relational
databases that I know have built-in collaboration features so that
people may access them from any part of the world; many have
replication features. I am not sure if "centralization" even fit into
the context.

> Here, we're simply looking for a standard way to capture an image
> (or more) with a task/note and tranport it back to your main Org
> file (a la Org Mobile or ...).  Org is lightweight in this area
> which is good and bad.

Regarding sizes:
================

$ du -skh .emacs.d/elpa/org-20201216/
11M	.emacs.d/elpa/org-20201216/

Database like   : sqlite3
Installed Size  : 7.55 MiB

Reference:

Relational database - Wikipedia:
https://en.wikipedia.org/wiki/Relational_database

You have misconception of what is lightweight or what is not or what
is difficult, I guess it comes simply from not trying it out. 

There is no "standard" way of taking notes, especially not in Org,
neither in Emacs environment, or generally for people.

Creating tables is pretty, new Emacs development has got SQLite built in:

(defun my-create-table-notes ()
      (rcd-sqlite "CREATE TABLE notes (
                      notes_id INTEGER NOT NULL PRIMARY KEY,
                      notes_datecreated TEXT NOT NULL DEFAULT (datetime()),
                      notes_datemodified TEXT NOT NULL DEFAULT (datetime()),
                      notes_name TEXT NOT NULL DEFAULT '>>>EDIT<<<',
                      notes_type INTEGER NOT NULL REFERENCES notetypes DEFAULT 1,
                      notes_text TEXT)"
		  rcd-people-sqlite-db))

Making a function to add a note is easy:

(defun rcd-db-table-sqlite-notes-insert-new-row ()
  "Add new note."
  (interactive)
  (let* ((name (read-string "Note name: "))
	 (prompt (format "Description about `%s': " name))
	 (note (string-edit "" "" 'ignore))
	 (sql (format "INSERT INTO notes (notes_name, notes_text)
                        VALUES (%s, %s) RETURNING notes_id"
		      (rcd-sqlite-escape-string name)
		      (rcd-sqlite-escape-string note)))
	 (id (rcd-sqlite-first sql rcd-people-sqlite-db)))
    id))

(defalias 'notes-add 'rcd-db-table-sqlite-notes-insert-new-row)

Viewing, listing, getting it back, making agendas, all that works
with so much less coding, works, less errors, and more speed.

Exporting to Org is easy:

(insert "\n\n"
	(rcd-sqlite-first "SELECT group_concat('** ' || notes_name || '\n\n' || notes_text,'\n\n') 
                           FROM notes 
                           ORDER BY notes_datecreated" rcd-people-sqlite-db))

** Something

My note #1

** My other heading

My note #2

** Something I knew before

My note #3

1

As Org users already wish and want to have structured properties,
tags, headings, links, tables, then it is right way to think that
with Emacs 29 and SQLite built-in, many things will become
easier.

Let us say keeping list of information such as accounting,
expenses, invoices, tasks, notes, etc. for any type of
information database has no ambiguity about structured
information, errors are minimized, programming efforts minimized. 

Pitfall would be that we would not have much discussion like now,
as with less bugs, there is less talk.

Imagine Org heading like this:

* My heading
  :PROPERTIES:
  :DB-ENTRY: :my-remote-host:my-database:my-org-table:id:1234
  :END:

Then imagine a pre-processor before saving the file or a hook for
saving Org file. Each time that file is saved, the heading entry could
be updated on remote host, database, table with ID 1234.  It could be
distributed, assigned, sent, easier shared, because data is
better estructured,

Or it could be updated in a local database.

Or it could be used to keep any kind information related to Org
heading. That is glue between the text file and well structured and
non ambiguous database.

If Org has mechanism to parse links in a file, a save hook could parse
them and store in database table for backlinks. 

Sometimes URL change, imagine Org link like: dbid:1234 that remains
immutable and which fetches the underlying dynamically updated URL.

If some Org headings are stored in the database, they may be updated
in Org file automatically.

Linking to Org headings could become so much more deterministic, as
one would link to unique ID in the database, no matter how heading is
named or where is it stored.

Collaboration door is open with networked databases. Concurrent access
to Org headings, links, contacts, becomes possible. Wide range of
options.

-- 
Jean

Take action in Free Software Foundation campaigns:
https://www.fsf.org/campaigns

In support of Richard M. Stallman
https://stallmansupport.org/

Re: Org and Hyperbole

[David Masterson]

Jean Louis <bugs@gnu.support> writes:

> * David Masterson <dsmasterson@gmail.com> [2022-10-10 19:55]:
>> Jean Louis <bugs@gnu.support> writes:
>> 
>> > * Robert Weiner <rsw@gnu.org> [2022-10-09 00:06]:
>> >> There are many reasons for this including limits in many
>> >> organizations of the file types that may be transferred through
>> >> common protocols and the difficulty of maintaining relational
>> >> database or structured file type schemas across time.
>> >
>> > I can't see how relational database is more difficult to maintain then
>> > for example Emacs itself. Emacs is master of difficulties for computer
>> > user. For example I have not touched configuration files for
>> > PostgreSQL since years, if not decades. I start wondering why.
>> 
>> The issue here is distribution.  Databases tend to be centralized and
>> heavy weight.
>
> What does it mean centralized in this context? Majority of Relational
> databases that I know have built-in collaboration features so that
> people may access them from any part of the world; many have
> replication features. I am not sure if "centralization" even fit into
> the context.

Hmm.  Perhaps replication is after my time with RDBs in the 80s-90s.  Be
that as it may, the process is more difficult than what is used by Org
now. Thinking about this more, I'm seeing possibilities with Org Mobile
as is.  I have to look at this more.

> Regarding sizes:
> ================
>
> $ du -skh .emacs.d/elpa/org-20201216/
> 11M	.emacs.d/elpa/org-20201216/
>
> Database like   : sqlite3
> Installed Size  : 7.55 MiB
>
> Reference:
>
> Relational database - Wikipedia:
> https://en.wikipedia.org/wiki/Relational_database
>
> You have misconception of what is lightweight or what is not or what
> is difficult, I guess it comes simply from not trying it out. 
>
> There is no "standard" way of taking notes, especially not in Org,
> neither in Emacs environment, or generally for people.

Taking notes?  Perhaps not.  Capturing tasks/notes is org-capture.

> [...]

Very interesting!

-- 
David Masterson

Re: Org and Hyperbole

[Jean Louis]

* David Masterson <dsmasterson@gmail.com> [2022-10-04 21:12]:
> Robert Weiner <rsw@gnu.org> writes:
> 
> > We welcome brief summaries of features you need for effective note
> > taking in Emacs.  We are not looking to do much with images or on
> > mobile devices, just focused on people who spend a lot of time in
> > Emacs and want an easy-to-use notes system that does not require any
> > external packages like SQLite.
> 
> One major use-case for Org is capturing a task quickly.  This can be
> done with Org or Mobile-Org (BeOrg, Orgzly).  One feature not easily
> available is attaching images to the task to better explain the task.

Do you mean capturing task? Or capturing note?

How does capturing task look like?


-- 
Jean

Take action in Free Software Foundation campaigns:
https://www.fsf.org/campaigns

In support of Richard M. Stallman
https://stallmansupport.org/

Re: Org and Hyperbole

[David Masterson]

Jean Louis <bugs@gnu.support> writes:

> * David Masterson <dsmasterson@gmail.com> [2022-10-04 21:12]:
>> Robert Weiner <rsw@gnu.org> writes:
>> 
>> > We welcome brief summaries of features you need for effective note
>> > taking in Emacs.  We are not looking to do much with images or on
>> > mobile devices, just focused on people who spend a lot of time in
>> > Emacs and want an easy-to-use notes system that does not require any
>> > external packages like SQLite.
>> 
>> One major use-case for Org is capturing a task quickly.  This can be
>> done with Org or Mobile-Org (BeOrg, Orgzly).  One feature not easily
>> available is attaching images to the task to better explain the task.
>
> Do you mean capturing task? Or capturing note?

Both actually.

> How does capturing task look like?

I'm simply looking for an enhancement and standard for tying a media
file (say, a iPhone photo) to a task/note such that the media file will
follow the task/note back to the main Org file as well as follow it back
out to the capture system.

I suppose this could be an enhancement to links in Org...?

-- 
David Masterson

Re: Org and Hyperbole

[Jean Louis]

* David Masterson <dsmasterson@gmail.com> [2022-10-10 19:51]:
> I'm simply looking for an enhancement and standard for tying a media
> file (say, a iPhone photo) to a task/note such that the media file will
> follow the task/note back to the main Org file as well as follow it back
> out to the capture system.
> 
> I suppose this could be an enhancement to links in Org...?

Every picture has its meta data. Exact location in Org file could be
specified directly inside of the image. Then you need a program which
will read the meta data and send you to Org file from the image. Maybe
there are some universal programs for that on your device.

-- 
Jean

Take action in Free Software Foundation campaigns:
https://www.fsf.org/campaigns

In support of Richard M. Stallman
https://stallmansupport.org/

Re: Org and Hyperbole

[Robert Weiner]

[-- Attachment #1: Type: text/plain, Size: 1404 bytes --]

Task management is a whole area separate from note taking.  This was
something I was interested in many years ago but have not been able to
publish a system to implement my ideas therein.  Since people generally
seem to be happy with Org's todo and agenda features, we expect to just
interact with those from Hyperbole.

But for notes, yes, one needs to capture them quickly and then get back to
your former context.  Later on you can process them more fully.

Although I see the great utility in having capabilities on mobile devices,
I find most apps way underpowered for constant use.  As Emacs becomes more
usable on mobile devices, we can add more mobile-friendly features to
Hyperbole.

-- rsw

On Tue, Oct 4, 2022 at 2:06 PM David Masterson <dsmasterson@gmail.com>
wrote:

> Robert Weiner <rsw@gnu.org> writes:
>
> > We welcome brief summaries of features you need for effective note
> > taking in Emacs.  We are not looking to do much with images or on
> > mobile devices, just focused on people who spend a lot of time in
> > Emacs and want an easy-to-use notes system that does not require any
> > external packages like SQLite.
>
> One major use-case for Org is capturing a task quickly.  This can be
> done with Org or Mobile-Org (BeOrg, Orgzly).  One feature not easily
> available is attaching images to the task to better explain the task.
>
> Thoughts on this?
>
> --
> David Masterson
>

[-- Attachment #2: Type: text/html, Size: 2334 bytes --]

Re: Org and Hyperbole

[Jean Louis]

* Robert Weiner <rsw@gnu.org> [2022-10-08 23:55]:
> Task management is a whole area separate from note taking.  This was
> something I was interested in many years ago but have not been able
> to publish a system to implement my ideas therein.  Since people
> generally seem to be happy with Org's todo and agenda features, we
> expect to just interact with those from Hyperbole.

PLEASE: Give us more information about your ideas and your system.

For me Org is only one of many lightweight markup languages,
definitely now the easiest or friendly one IMHO. Asciidoc is way
easier and asciidoctor implementation offers better higher level and
deterministic functions for users to create documents.

AsciiDoc Syntax Quick Reference | Asciidoctor Docs:
https://docs.asciidoctor.org/asciidoc/latest/syntax-quick-reference/

I get better output, easier workflow with Asciidoctor and PDF rather
than with Org. Sometimes I may use txt2tags and generate asciidoc. I
get less problems with it, rather than with LaTeX.

And I don't think that Org is proper for task management. Org is
markup for me, and that is where I keep it. 

Tasks must be modular and separate from text files, external and
editable by many means, and accessible by multiple people from
multiple parts of the world. That is what various ERP, CRM systems
already do for people.

Org group of users are limited. There is no need to think that Org
users are leading in the subject of task management, as they are
not. They are troubled by too many problems, too many errors, and
constant inability to actually do what they want.

Just compare it to Cherrytree or Leo editor:

Cherrytree - hierarchical note taking application with rich text and syntax highlighting:
https://www.giuspen.com/cherrytree/

Leo programmable editor:
http://leoeditor.com/

In Org we are enthusiastic.

We are many unrealistic, and idealistic. That is not objective.

With Org one can't assume that productivity is granted.

Productivity comes from person skilled in handling its own tasks, not
from the tool.

Like you with Hyrolo, I guess you are using it very swift and smooth,
but I do not see anybody on mailing list talking about it. Great tool
with too few users. Org has too many users and also too many problems. 

I have no problems adding contacts to Hyrolo and searching, deleting,
finding phone numbers, it works swift. Not that I use it, but without
access to my database, on some remote computers in forest, that is
what I like to use.

I can't say that I am happy with Org agenda, far from that, in fact I
never use it because I was not happy. So I made my own, and it is
soooo much faster than Org agenda, because it gets it from users.

So please GIVE us the list of your ideas, as it may be useful.

> But for notes, yes, one needs to capture them quickly and then get
> back to your former context.  Later on you can process them more
> fully.

"Capturing" notes like some mouses or animals, I don't know if that
word is appropriate. Do you people in English speaking area in world
without Emacs really use the word "capturing".

Org has promoted features like swift templates on how to insert new
information into text files.

Function skeleton-insert is since 1993 there in Emacs as one of ways
how to insert in any mode new template based information. It was just
not as promoted as Org mode.

By promoting "capturing" ideas to be somehow connected exclusively to
Org mode we lure people rather into pretty difficult environment. 

This way we just limit people to think that templates and quicker and
streamlined note taking can't be used in other modes or text files.

What a silly situation.

And when I just look on the interface of M-x org-capture, I can't even
believe people use that static what, Emacs-blocking screen. I can't
even switch to that buffer. And I do not need tips "how to do it" as a
follow up to this paragraph. 

I use org-protocol as one of ways to enter information to Emacs,
because I use browser extension for Org protocol. 

But I never record anything into Org files directly.

Org protocol may is described as:
Intercept Calls from Emacsclient to Trigger Custom Actions

Great idea, but why it should be limited to Org?

So I use it to enter information straight into database by using
Firefox extension: https://github.com/vifon/org-protocol-for-firefox

> Although I see the great utility in having capabilities on mobile
> devices, I find most apps way underpowered for constant use.

I can totally agree with that statement. 

One good application on mobile devices that I use is simple text
editor. That is where I enter notes. Then I connect mobile device to
Emacs and move those notes into the database.

> As Emacs becomes more usable on mobile devices, we can add more
> mobile-friendly features to Hyperbole.

Emacs works well in Termux in Android, Lineage OS, Replicant
systems. Problem is not in Emacs which already works well in console
mode. 

Problem is with the keyboard. Mobile devices with virtual keyboards
are not suitable for advanced Emacs key bindings.

-- 
Jean

Take action in Free Software Foundation campaigns:
https://www.fsf.org/campaigns

In support of Richard M. Stallman
https://stallmansupport.org/

Re: Org and Hyperbole

[David Masterson]

Robert Weiner <rsw@gnu.org> writes:

> Task management is a whole area separate from note taking.  This was something I was interested in many years ago but have not been able to publish a system to implement my ideas
> therein.  Since people generally seem to be happy with Org's todo and agenda features, we expect to just interact with those from Hyperbole.
>
> But for notes, yes, one needs to capture them quickly and then get back to your former context.  Later on you can process them more fully.
>
> Although I see the great utility in having capabilities on mobile devices, I find most apps way underpowered for constant use.  As Emacs becomes more usable on mobile devices, we can
> add more mobile-friendly features to Hyperbole.

Because of mobile devices, tasks/notes are not just text.
 
-- 
David Masterson

Re: Org and Hyperbole

[Jean Louis]

* Robert Weiner <rsw@gnu.org> [2022-10-04 09:26]:
> Thanks, Jean.  We have started work on a note-taking subsystem for
> Hyperbole that will store UUIDs per note and will likely support backlinks
> too.  We are seeing if we can make it support Koutlines, Emacs Outlines,
> Org mode files and Markdown files, searching across all formats at the same
> time.  The default for creating new notes will likely be a personal
> Koutline file.

I understand Koutline to become something like store for notes. In my
case I use database as store. Please note that Emacs development
version has SQLite built-in, it is not really external package. And
having intentionally generic functions with drivers to store
information as text, as SQLite, PostgreSQL, etc -- is rather
beneficial, not detrimental. Text can be default, but it is not
scalable.

> We welcome brief summaries of features you need for effective note taking
> in Emacs.  We are not looking to do much with images or on mobile devices,
> just focused on people who spend a lot of time in Emacs and want an
> easy-to-use notes system that does not require any external packages like
> SQLite.

Me personally I do require external database. Maybe I work too much,
statistics may tell. Think about it, when there is external database,
one can access it through multiple users from multiple devices in the
world without storing (much) information on the used computer.

┌───────────────────────────────┬───────┐
│ Statistics for last 12 months │ Count │
├───────────────────────────────┼───────┤
│ People lists                  │   242 │
│ Emails sent                   │  3565 │
│ Hyperscope, new objects       │  9928 │
│ Hyperscope, objects sent      │  4147 │
│ Hyperscope objects tagged     │ 35642 │
│ Hyperscope, people related    │  4226 │
│ Mailings sent                 │ 30767 │
│ New People                    │  2293 │
│ People, tagged                │ 61099 │
│ SMS Sent                      │ 24493 │
│ New Tags                      │   410 │
└───────────────────────────────┴───────┘

The feature I need is specific to customizable Hyperbole buttons to be
able to detect if button was invoked by Hyperbole or not, as that way
I can make self-destructive hyperlinks or universal hyperlinks that
appear appropriately to lightweight markup language such as Org,
markdown, asciidoctor, etc.; or to have double or tripe directional
links depending of the context: activating link by Hyperbole could
show me details about person in the database, but exporting the same
link from Org mode could prepare Org links and "name" of person in the
Org link and it could activate person's website instead of personal
details.

-- 
Jean

Take action in Free Software Foundation campaigns:
https://www.fsf.org/campaigns

In support of Richard M. Stallman
https://stallmansupport.org/

Re: Org and Hyperbole

[Jean Louis]

* Samuel Wales <samologist@gmail.com> [2022-06-24 07:33]:
> hi robert, welcome to the org list and thanks for your offer.
> 
> for starters, does hyperbole have any concept of links that are:
> 
> - unbreakable [like org-id]
> 
> - bidirectional [link a goes to link b; link b goes to link a], or,
> reversible via command to say "what links here?" [by any mechanism.
> if desired, please see "id markers" concept on this list for
> unbreakable bidirectional links and more stuff]

I was experimenting with idea of backlinks since 1 year, 3 months and
14 days. For me personally, it is not easy, but I managed to record
backlinks. Let us say I am writing email, insert link there, the link
that I inserted it in the email will know that I inserted it in the
email, and its file name, but it will not know the ID of the person to
which email belonged. Maybe I could handle the best mail software for
Emacs (mutt) to send some information about currently replied email
address to connect to it.

Otherwise if I use some kind of interpolated links like:
⟦ (link 123 "Name") ⟧
then each interpolation could eventually make the link remember where
it was inserted.

My note buffers have different local variables: rcd-current-table
refers to table in database, such as "hyobjects" (elementary objects
in terms of Doug Engelbart), and there is rcd-current-table-id such as
1, which refers to the row #1 in table hyobjects. Inserting link into
the buffer like that makes the link notify that it was inserted
there. But how it is going to remember when the link disappears?

The only way to go for backlinks to be remembered at all times is to
treat them as elementary objects, see:

https://www.dougengelbart.org/content/view/116/#7j

Elementary Objects:
https://www.dougengelbart.org/content/view/110/460/#2a1a

Imagine elementary objects under a list named "Document":

1 Introduction paragraph
2 link #1
3 link #2
4 Image
5 Body of document

Now imagine document being joined together, something like:

Introduction paragraph (link #1) Body of document

In that way when all elementary parts would be considered, one could
get full control over backlinks. It seems tedious at first. It need
not be.

Let us say I am in the set of elementary objects named "Body" and I am
inserting links there. The set itself is the list of elementary
object. A function to insert hyperlink can in same time record which
other elementary object is inserted in which object and keep it in the
set list. This way record remains for later back linking. The link can
know where it was linked from.

When handling database objects hyperlinking and backlinking is a must
and mostly built-in.

-- 
Jean

Take action in Free Software Foundation campaigns:
https://www.fsf.org/campaigns

In support of Richard M. Stallman
https://stallmansupport.org/

Re: Org and Hyperbole

[Eduardo Ochs]

On Thu, 23 Jun 2022 at 22:47, Robert Weiner <rsw@gnu.org> wrote:
>
> I am the author of Hyperbole and would be happy to answer questions
> concerning Hyperbole today (so you don't have to answer based on
> experience from the 1990s).  Hyperbole has been modernized for use
> with Org mode and Emacs 28 and continues to develop.  There are videos
> that demonstrate some of its features in simple, understandable ways.
> Hyperbole is a single Emacs package that can be installed and
> uninstalled quickly for testing.  It is largely a global minor mode,
> so you can also disable it quickly if you ever care to.  In 20 minutes
> you can get through the builtin, interactive demo and be on your way
> to basic yet powerful usage.  We have listened to much feedback in the
> last few years and made it much more approachable.


Hi Robert,

can you show us a sexp that will disable Hyperbole completely, and
that we can execute with our favorite variants of `C-x C-e'?
I know that this page

  (info "(hyperbole)Default Hyperbole Bindings")

has this paragraph,

  {C-h h}
  {C-h h X}
     Hyperbole Mini Menu: Enable Hyperbole minor mode and invoke the
     Hyperbole minibuffer menu, giving access to many Hyperbole
     commands.  This is bound globally.  Use {C-h h X} to close the
     Hyperbole minibuffer menu and disable Hyperbole minor mode.

and apparently these sexps toggle Hyperbole minor mode,

  (hyperbole-mode 1)
  (hyperbole-mode 0)

but even when I toggle it off the global binding for `C-h h' remains
active...

  Thanks in advance.
  My notes on Hyperbole are here,
    http://angg.twu.net/hyperbole.html
  and there is some material on why I find Hyperbole too "magic"
  in these two links:
    http://angg.twu.net/2021-org-for-non-users.html
    http://angg.twu.net/eev-wconfig.html

  [[]],
    Eduardo Ochs
    http://angg.twu.net/#eev

Re: Org and Hyperbole

[Robert Weiner]

[-- Attachment #1: Type: text/plain, Size: 434 bytes --]

Hi Eduardo:

I hope you'll take another look.

(hyperbole-mode 0)  disables the Hyperbole minor mode and all of its key
bindings.
The global binding {C-h h} is left in place so that you can quickly
re-enable Hyperbole's
minor mode and display its navigational minibuffer menu (where quick keys
let you
rapidly access a lot of Hyperbole capabilities.  You can unbind this global
key as you do
any other:

   (global-unset-key "\C-hh")

[-- Attachment #2: Type: text/html, Size: 1964 bytes --]

Re: Org and Hyperbole

[Robert Weiner]

[-- Attachment #1: Type: text/plain, Size: 711 bytes --]

Typically:
{M-x package-install RET hyperbole RET}
{M-x hyperbole-mode RET}

is enough to install the stable, V8 version of Hyperbole to try out.

If you are more advanced and want to try out the in-development version
that corresponds to the git tip of the Hyperbole master branch, this is
available
as a package from the elpa-devel archive.  To setup to install from there,
see
this article:

  https://protesilaos.com/codelog/2022-05-13-emacs-elpa-devel/

or just add:

    (push '("elpa-devel" . "https://elpa.gnu.org/devel/") package-archives)

to your Emacs init.

Built-in Org support for Hyperbole is documented here:


https://www.gnu.org/software/hyperbole/man/hyperbole.html#Smart-Key-_002d-Org-Mode

[-- Attachment #2: Type: text/html, Size: 1691 bytes --]

Re: Org and Hyperbole

[Tim Cross]

Hi Robert,

welcome to the list. 

I find hyperbole very interesting and am trying it out now. I can see a
few areas where I think it may augment my current org based workflows
and development tasks. 

One thing I will be looking at is how well hyperbole works with an
evil-mode based configuration. Probably no big effect with regards to
basic links and things like the interesting roladex type system, but may
be relevant with regards to koutline. 

At this stage, I'm thinking hyperbole might be good as a basic
'dashboard' type startup screen which makes selecting projects or Emacs
based apps (like this mu4e environment) easy to select. I likely won't
take advantage of the window/frame management stuff as I now tend to
work mainly with emacs tabs - I rarely even split windows anymore and
now tend to just have one big frame with many tabs or tab groups. 

It will be interesting to see if there are areas where org mode and
hyperbole may further enhance each other. I see them as having good
collaboration potential rather than as competing/conflicting systems. 

Re: Org and Hyperbole

[Robert Weiner]

[-- Attachment #1: Type: text/plain, Size: 2190 bytes --]

Hi Tim:

Great to see you working with Org and Hyperbole together.  It is funny you
mention a dashboard as that is the main next feature we are working on for
Hyperbole.  Presently, there is a 'personal button file' that serves as
your launch pad for any commonly used hyperbuttons, accessed with {C-h h b
p}.  There is a similar per directory file, {C-h h b d}, any of which can
be Org files or any format you prefer.  To augment the personal file, we
plan on adding a quick access menu to search, jump to and edit your
personal, commonly used Hyperbole, Emacs and Org constructs that would
serve as a dashboard, bringing together a lot of the hyper capabilities
distributed throughout Emacs, including all categories of Hyperbole
buttons, Org files, bookmarks, URLs, agenda items, notes, todos, etc. And
each type will be customizable so you can use your favorite feature whether
from Org, Hyperbole or another package.  It is in early development now, so
feel free to mention any wishlist items.



On Fri, Jun 24, 2022 at 2:44 AM Tim Cross <theophilusx@gmail.com> wrote:

>
> Hi Robert,
>
> welcome to the list.
>
> I find hyperbole very interesting and am trying it out now. I can see a
> few areas where I think it may augment my current org based workflows
> and development tasks.
>
> One thing I will be looking at is how well hyperbole works with an
> evil-mode based configuration. Probably no big effect with regards to
> basic links and things like the interesting roladex type system, but may
> be relevant with regards to koutline.
>
> At this stage, I'm thinking hyperbole might be good as a basic
> 'dashboard' type startup screen which makes selecting projects or Emacs
> based apps (like this mu4e environment) easy to select. I likely won't
> take advantage of the window/frame management stuff as I now tend to
> work mainly with emacs tabs - I rarely even split windows anymore and
> now tend to just have one big frame with many tabs or tab groups.
>
> It will be interesting to see if there are areas where org mode and
> hyperbole may further enhance each other. I see them as having good
> collaboration potential rather than as competing/conflicting systems.
>
>

[-- Attachment #2: Type: text/html, Size: 2960 bytes --]

Re: Org and Hyperbole

[Juan Manuel Macías]

Hi, Robert,

First of all, welcome to the list. And of course congratulations on all
the great work you've done with hyperbole. In my ignorance, when I
recently installed it from ELPA, I thought it was a relatively recent
package. But it seems that you have been developing it for a long time,
while adapting it to the latest GNU Emacs trends. This is fortunate,
because what is new is combined with experience and the residue of work
already done over the years.

At the moment I am not going to comment here anything specific on the
technical level, because I have been using hyperbole for a short time
and my knowledge of this package is still very limited. I think the best
strategy for using hyperbole, from a user's point of view, is to simply
use it. And gradually discover which parts of hyperbole can be useful
and integrate into one's workflow. This is more practical than trying to
start from a global conceptual base (IMHO). I'm still having trouble
explaining what Org is for and what Org really is :-). But this is also
the case with Emacs itself. When I first started using Emacs I thought
it was just a text editor, like any other text editor. In fact, on my
first day with Emacs I hated it dearly and uninstalled it in a rage. Now
it's my desktop environment and my work environment, with EXWM, with
Org, among others, and hopefully with Hyperbole as well. I suppose that
it is the daily use that is making us connect the dots...

I really like the implicit link system, and it is really easy to define
new links. I have already defined a set of new buttons for LaTeX, which
recognize commands and environments and point to the local TeX live
documentation or texstackexchange.com. And with avy they work great.
Have you thought about giving a support for avy? In any case it is easy
to add a new avy action to avy-dispatch-alist.

Best regards,

Juan Manuel 

Robert Weiner writes:

> Hi:
>
> Thanks to Juan for starting this thread and the interesting
> conversation it has started.  I just joined this mail list, so I don't
> have the prior messages and can't reply to the thread, so I have
> started this new one.
>
> I am the author of Hyperbole and would be happy to answer questions
> concerning Hyperbole today (so you don't have to answer based on
> experience from the 1990s).  Hyperbole has been modernized for use
> with Org mode and Emacs 28 and continues to develop.  There are videos
> that demonstrate some of its features in simple, understandable ways.
> Hyperbole is a single Emacs package that can be installed and
> uninstalled quickly for testing.  It is largely a global minor mode,
> so you can also disable it quickly if you ever care to.  In 20 minutes
> you can get through the builtin, interactive demo and be on your way
> to basic yet powerful usage.  We have listened to much feedback in the
> last few years and made it much more approachable.
>
> I find most of the confusion is people trying to understand how
> Hyperbole works under the covers rather than just following the
> tutorial and exploring it.  Hyperbole can be hacked on if you are a
> moderate to advanced programmer but it is meant to be used, like Org
> mode.  Hyperbole recognizes many, many common contexts in buffers that
> could serve as hyperlinks (paths, URLs, multiple key sequences, mail
> addresses, and on and on) and performs the typically desired action
> when you press its Action Key {M-RET} on these 'implicit buttons'.
> You get all this for free with no effort on your part.  Then if you
> want to extend such behavior, as you have seen a bit of, you can
> define your own implicit button and action types once and then
> activate an infinite number of matching implicit buttons.  For
> example, in an Emacs shell buffer, type:
>
>    echo $PATH
>
> then press the {M-RET} key or Shift-Middle mouse button on any path
> there and jump right to it.  I find that very useful as a simple
> example.  People are often surprised at how many things simply work
> right out of the box because such broad context-sensitive behavior is
> difficult to develop and rarely seen.  Just try it out and you should
> find some contexts that you can leverage rapidly.  {C-h A} displays
> what Hyperbole's Action Key will do in any context so you can always
> check and learn before activating anything.  We say: Hyperbole brings
> your text to life.  Like Org and Emacs, it provides an extensive
> environment that you can grow into across time, getting ever more
> productive rather than hitting a ceiling as with most point
> packages/tools.
>
> I am happy to answer questions and discuss ways we can make Hyperbole
> and Org work even better together; one direct question per message
> would typically work best.  Responses may take awhile as my schedule
> makes it difficult to keep up with high volume mailing lists but if
> you cc: rsw@gnu.org, I'll likely see your message faster and respond.

Re: Org and Hyperbole

[Robert Weiner]

[-- Attachment #1: Type: text/plain, Size: 6013 bytes --]

Hi Juan:

Thanks for the positive thoughts on Hyperbole.  I must say everyone here
has a great attitude and writes thoughtfully from what I have seen.

It seems like you are off to a good start utilizing core features as you
get familiar with them and then adding on across time.

We do like avy and as you say, Hyperbole can work with it.  We try to avoid
requiring any non-builtin Emacs packages for Hyperbole.  With a few, we
support them optionally.  Unless there is a strong use case for utilizing
avy in certain ways, we would tend to leave that to others to extend
Hyperbole but personally I just add it in and use its character and line
navigation sometimes.  Did you have any particular uses in mind?

-- rsw


On Fri, Jun 24, 2022 at 9:52 AM Juan Manuel Macías <maciaschain@posteo.net>
wrote:

> Hi, Robert,
>
> First of all, welcome to the list. And of course congratulations on all
> the great work you've done with hyperbole. In my ignorance, when I
> recently installed it from ELPA, I thought it was a relatively recent
> package. But it seems that you have been developing it for a long time,
> while adapting it to the latest GNU Emacs trends. This is fortunate,
> because what is new is combined with experience and the residue of work
> already done over the years.
>
> At the moment I am not going to comment here anything specific on the
> technical level, because I have been using hyperbole for a short time
> and my knowledge of this package is still very limited. I think the best
> strategy for using hyperbole, from a user's point of view, is to simply
> use it. And gradually discover which parts of hyperbole can be useful
> and integrate into one's workflow. This is more practical than trying to
> start from a global conceptual base (IMHO). I'm still having trouble
> explaining what Org is for and what Org really is :-). But this is also
> the case with Emacs itself. When I first started using Emacs I thought
> it was just a text editor, like any other text editor. In fact, on my
> first day with Emacs I hated it dearly and uninstalled it in a rage. Now
> it's my desktop environment and my work environment, with EXWM, with
> Org, among others, and hopefully with Hyperbole as well. I suppose that
> it is the daily use that is making us connect the dots...
>
> I really like the implicit link system, and it is really easy to define
> new links. I have already defined a set of new buttons for LaTeX, which
> recognize commands and environments and point to the local TeX live
> documentation or texstackexchange.com. And with avy they work great.
> Have you thought about giving a support for avy? In any case it is easy
> to add a new avy action to avy-dispatch-alist.
>
> Best regards,
>
> Juan Manuel
>
> Robert Weiner writes:
>
> > Hi:
> >
> > Thanks to Juan for starting this thread and the interesting
> > conversation it has started.  I just joined this mail list, so I don't
> > have the prior messages and can't reply to the thread, so I have
> > started this new one.
> >
> > I am the author of Hyperbole and would be happy to answer questions
> > concerning Hyperbole today (so you don't have to answer based on
> > experience from the 1990s).  Hyperbole has been modernized for use
> > with Org mode and Emacs 28 and continues to develop.  There are videos
> > that demonstrate some of its features in simple, understandable ways.
> > Hyperbole is a single Emacs package that can be installed and
> > uninstalled quickly for testing.  It is largely a global minor mode,
> > so you can also disable it quickly if you ever care to.  In 20 minutes
> > you can get through the builtin, interactive demo and be on your way
> > to basic yet powerful usage.  We have listened to much feedback in the
> > last few years and made it much more approachable.
> >
> > I find most of the confusion is people trying to understand how
> > Hyperbole works under the covers rather than just following the
> > tutorial and exploring it.  Hyperbole can be hacked on if you are a
> > moderate to advanced programmer but it is meant to be used, like Org
> > mode.  Hyperbole recognizes many, many common contexts in buffers that
> > could serve as hyperlinks (paths, URLs, multiple key sequences, mail
> > addresses, and on and on) and performs the typically desired action
> > when you press its Action Key {M-RET} on these 'implicit buttons'.
> > You get all this for free with no effort on your part.  Then if you
> > want to extend such behavior, as you have seen a bit of, you can
> > define your own implicit button and action types once and then
> > activate an infinite number of matching implicit buttons.  For
> > example, in an Emacs shell buffer, type:
> >
> >    echo $PATH
> >
> > then press the {M-RET} key or Shift-Middle mouse button on any path
> > there and jump right to it.  I find that very useful as a simple
> > example.  People are often surprised at how many things simply work
> > right out of the box because such broad context-sensitive behavior is
> > difficult to develop and rarely seen.  Just try it out and you should
> > find some contexts that you can leverage rapidly.  {C-h A} displays
> > what Hyperbole's Action Key will do in any context so you can always
> > check and learn before activating anything.  We say: Hyperbole brings
> > your text to life.  Like Org and Emacs, it provides an extensive
> > environment that you can grow into across time, getting ever more
> > productive rather than hitting a ceiling as with most point
> > packages/tools.
> >
> > I am happy to answer questions and discuss ways we can make Hyperbole
> > and Org work even better together; one direct question per message
> > would typically work best.  Responses may take awhile as my schedule
> > makes it difficult to keep up with high volume mailing lists but if
> > you cc: rsw@gnu.org, I'll likely see your message faster and respond.
>
>

[-- Attachment #2: Type: text/html, Size: 7561 bytes --]

Re: Org and Hyperbole

[Juan Manuel Macías]

Hi, Robert,

Robert Weiner writes:

> We do like avy and as you say, Hyperbole can work with it.  We try to
> avoid requiring any non-builtin Emacs packages for Hyperbole.  With a
> few, we support them optionally.  Unless there is a strong use case
> for utilizing avy in certain ways, we would tend to leave that to
> others to extend Hyperbole but personally I just add it in and use its
> character and line navigation sometimes.  Did you have any particular
> uses in mind?

My use of the mouse within Emacs is practically nonexistent, and outside
of Emacs I have relegated the mouse to a few graphical applications such
as Gimp, Krita, Scribus, and little else. That's why I find avy
extremely handy for quickly navigating through text. By adding an action
to avy-dispatch-alist you can execute an arbitrary command once the
cursor has jumped to its target. For example, I have put this for
hyperbole in my init:

(add-to-list 'avy-dispatch-alist '(?: . (lambda (pt)
					  (goto-char pt)
					  (hkey-either))))

Thus, the typical action to activate a 'far' hyperbole button would be:

1. Call avy and insert a letter;

2. When avy's hints are displayed in the screen, I hit the colon key ":"
and then the hint letter I want to go to (an implicit button, for
example). And at the moment the associated action of that button is
executed.

For those of us who hardly use the mouse, it is really very practical,
and I think maybe mentioning that tip might be nice in the hyperbole
documentation.

Best regards,

Juan Manuel 

Re: Org and Hyperbole

[Robert Weiner]

Good idea, Juan.  I’m all for quick ways to activate buttons without losing your current context.  I’ll take a look at how we might support this as an optional load.

-- Bob

> On Jun 25, 2022, at 10:32 AM, Juan Manuel Macías <maciaschain@posteo.net> wrote:
> 
> Hi, Robert,
> 
> Robert Weiner writes:
> 
>> We do like avy and as you say, Hyperbole can work with it.  We try to
>> avoid requiring any non-builtin Emacs packages for Hyperbole.  With a
>> few, we support them optionally.  Unless there is a strong use case
>> for utilizing avy in certain ways, we would tend to leave that to
>> others to extend Hyperbole but personally I just add it in and use its
>> character and line navigation sometimes.  Did you have any particular
>> uses in mind?
> 
> My use of the mouse within Emacs is practically nonexistent, and outside
> of Emacs I have relegated the mouse to a few graphical applications such
> as Gimp, Krita, Scribus, and little else. That's why I find avy
> extremely handy for quickly navigating through text. By adding an action
> to avy-dispatch-alist you can execute an arbitrary command once the
> cursor has jumped to its target. For example, I have put this for
> hyperbole in my init:
> 
> (add-to-list 'avy-dispatch-alist '(?: . (lambda (pt)
>                      (goto-char pt)
>                      (hkey-either))))
> 
> Thus, the typical action to activate a 'far' hyperbole button would be:
> 
> 1. Call avy and insert a letter;
> 
> 2. When avy's hints are displayed in the screen, I hit the colon key ":"
> and then the hint letter I want to go to (an implicit button, for
> example). And at the moment the associated action of that button is
> executed.
> 
> For those of us who hardly use the mouse, it is really very practical,
> and I think maybe mentioning that tip might be nice in the hyperbole
> documentation.
> 
> Best regards,
> 
> Juan Manuel 

Re: Org and Hyperbole

[Robert Weiner]

[-- Attachment #1: Type: text/plain, Size: 2155 bytes --]

Hi Juan:

I just tried your ':' technique for Hyperbole button activation with Avy
and it works well.  But what is the advantage over just using Avy to jump
to the button and then pressing {M-RET}.  With your technique, you have to
think about activating the button before you are there versus when you are
on it, as you normally do.

-- rsw


On Sat, Jun 25, 2022 at 10:32 AM Juan Manuel Macías <maciaschain@posteo.net>
wrote:

> Hi, Robert,
>
> Robert Weiner writes:
>
> > We do like avy and as you say, Hyperbole can work with it.  We try to
> > avoid requiring any non-builtin Emacs packages for Hyperbole.  With a
> > few, we support them optionally.  Unless there is a strong use case
> > for utilizing avy in certain ways, we would tend to leave that to
> > others to extend Hyperbole but personally I just add it in and use its
> > character and line navigation sometimes.  Did you have any particular
> > uses in mind?
>
> My use of the mouse within Emacs is practically nonexistent, and outside
> of Emacs I have relegated the mouse to a few graphical applications such
> as Gimp, Krita, Scribus, and little else. That's why I find avy
> extremely handy for quickly navigating through text. By adding an action
> to avy-dispatch-alist you can execute an arbitrary command once the
> cursor has jumped to its target. For example, I have put this for
> hyperbole in my init:
>
> (add-to-list 'avy-dispatch-alist '(?: . (lambda (pt)
>                                           (goto-char pt)
>                                           (hkey-either))))
>
> Thus, the typical action to activate a 'far' hyperbole button would be:
>
> 1. Call avy and insert a letter;
>
> 2. When avy's hints are displayed in the screen, I hit the colon key ":"
> and then the hint letter I want to go to (an implicit button, for
> example). And at the moment the associated action of that button is
> executed.
>
> For those of us who hardly use the mouse, it is really very practical,
> and I think maybe mentioning that tip might be nice in the hyperbole
> documentation.
>
> Best regards,
>
> Juan Manuel
>

[-- Attachment #2: Type: text/html, Size: 3067 bytes --]

Re: Org and Hyperbole

[Juan Manuel Macías]

Robert Weiner writes:

> Hi Juan:
>
> I just tried your ':' technique for Hyperbole button activation with
> Avy and it works well.  But what is the advantage over just using Avy
> to jump to the button and then pressing {M-RET}.  With your technique,
> you have to think about activating the button before you are there
> versus when you are on it, as you normally do.

Hi, Robert,

Thanks for your comment. I agree with what you say. I'm afraid this
action, as I proposed it, is impractical. The proof is that I haven't
used it too much :-). Avy also includes some factory keys where the
action is performed on the target without losing focus or cursor
position. For example, to copy a "distant" word and paste at point. This
would be a more reasonable use case. Taking inspiration from Avy's code
for these actions, I've defined this new version:

(add-to-list 'avy-dispatch-alist '(?: . (lambda (pt)
                                          (goto-char pt)
                                          (hkey-either)
                                          (let ((dat (ring-ref avy-ring 0)))
                                            (select-frame-set-input-focus
                                             (window-frame (cdr dat)))
                                            (select-window (cdr dat))
                                            (goto-char (car dat))))))

Now hkey-either would run without losing the current focus and cursor
position. An example of use that occurs to me: for my translation of the
Odyssey into Spanish I have defined some implicit buttons that do the
following: if they are activated in a certain positions of the verse
(for example, at the beginning of the verse), it is shown in a temporary
postframe: a) the verse translated by me if the action is performed on
the original Greek verse and b) the original Greek verse if the action
is on the translated verse.

I think that is better seen in this short video:

https://cloud.disroot.org/s/4c7ZFCAPTercgMS

Best regards,

Juan Manuel

Re: Org and Hyperbole

[João Pedro]

Hey Robert. Thanks for coming here to offer to clarify any doubts people
have regarding Hyperbole.

I haven't been interacting with the thread, but I've been lurking about
and I've tried Hyperbole in the past, but couldn't precisely figure out
its use case in my particular workflow, so I gave up on it.

Now, according to your description, the main feature of Hyperbole looks
a lot like what Embark [1] does sort of the same thing, albeit in
different contexts, complexity (not a bad thing) and workflow. Would you
be able to compare them? I think it would help me understand where
exactly Hyperbole fits, and what is the problem it tries to solve.

[1] https://github.com/oantolin/embark

Best regards,

-- 
João Pedro de A. Paula
IT undergraduate at Universidade Federal do Rio Grande do Norte (UFRN)

Re: Org and Hyperbole

[Robert Weiner]

[-- Attachment #1: Type: text/plain, Size: 2812 bytes --]

Hi João:

Oantolin no doubt can speak to Embark much better but my present
understanding is that it is a toolkit package for generating contextual
popup or completion menus with a few standard context menus included.

Hyperbole is a much broader personal information management
environment, one part of which is to turn every common type of
cross-reference found in buffers from programming identifiers to
page links into immediately useable hyperlinks with no effort
or markup on your part (implicit buttons).

Hyperbole includes a large array of implicit buttons and context
awareness, rather than expecting you to write your own solutions
to all of your needs.  It is more turn-key.  One appendix in the
Hyperbole manual is filled with all the contexts and associated
actions that Hyperbole supports out of the box:

https://www.gnu.org/software/hyperbole/man/hyperbole.html#toc-Smart-Key-Reference-1

Other features include: named hyperbuttons accessed from any
buffer, advanced contact management or hierarchical record
searching (point HyRolo at Org files and you can find single
entries within hierarchies), automatable frame and window
management, action triggers from mouse drags, Org hyperbutton
activation outside of Org mode, easy menu-based exposure of
Emacs filtering and searching capabilities, quick grid-based
display of desired buffers or files.  Hyperbole puts your textual
information at your fingertips in a myriad of ways, just as Emacs
makes text editing convenient and flexible in a myriad of ways.

Like Emacs, you are expected to grow into a broad away of uses across time,
not to digest all at once or in your first month of use.  But by learning
and combining
capabilities, you can become masterful at managing your information and Org
can
be a big part of this journey as well.

Enjoy.

-- rsw


On Fri, Jun 24, 2022 at 1:57 PM João Pedro <jpedrodeamorim@gmail.com> wrote:

> Hey Robert. Thanks for coming here to offer to clarify any doubts people
> have regarding Hyperbole.
>
> I haven't been interacting with the thread, but I've been lurking about
> and I've tried Hyperbole in the past, but couldn't precisely figure out
> its use case in my particular workflow, so I gave up on it.
>
> Now, according to your description, the main feature of Hyperbole looks
> a lot like what Embark [1] does sort of the same thing, albeit in
> different contexts, complexity (not a bad thing) and workflow. Would you
> be able to compare them? I think it would help me understand where
> exactly Hyperbole fits, and what is the problem it tries to solve.
>
> [1] https://github.com/oantolin/embark
>
> Best regards,
>
> --
> João Pedro de A. Paula
> IT undergraduate at Universidade Federal do Rio Grande do Norte (UFRN)
>

[-- Attachment #2: Type: text/html, Size: 9660 bytes --]

Re: Org and Hyperbole

[Samuel Wales]

is there a mailing list for embark?

On 6/24/22, Robert Weiner <rsw@gnu.org> wrote:
> Hi João:
>
> Oantolin no doubt can speak to Embark much better but my present
> understanding is that it is a toolkit package for generating contextual
> popup or completion menus with a few standard context menus included.
>
> Hyperbole is a much broader personal information management
> environment, one part of which is to turn every common type of
> cross-reference found in buffers from programming identifiers to
> page links into immediately useable hyperlinks with no effort
> or markup on your part (implicit buttons).
>
> Hyperbole includes a large array of implicit buttons and context
> awareness, rather than expecting you to write your own solutions
> to all of your needs.  It is more turn-key.  One appendix in the
> Hyperbole manual is filled with all the contexts and associated
> actions that Hyperbole supports out of the box:
>
> https://www.gnu.org/software/hyperbole/man/hyperbole.html#toc-Smart-Key-Reference-1
>
> Other features include: named hyperbuttons accessed from any
> buffer, advanced contact management or hierarchical record
> searching (point HyRolo at Org files and you can find single
> entries within hierarchies), automatable frame and window
> management, action triggers from mouse drags, Org hyperbutton
> activation outside of Org mode, easy menu-based exposure of
> Emacs filtering and searching capabilities, quick grid-based
> display of desired buffers or files.  Hyperbole puts your textual
> information at your fingertips in a myriad of ways, just as Emacs
> makes text editing convenient and flexible in a myriad of ways.
>
> Like Emacs, you are expected to grow into a broad away of uses across time,
> not to digest all at once or in your first month of use.  But by learning
> and combining
> capabilities, you can become masterful at managing your information and Org
> can
> be a big part of this journey as well.
>
> Enjoy.
>
> -- rsw
>
>
> On Fri, Jun 24, 2022 at 1:57 PM João Pedro <jpedrodeamorim@gmail.com>
> wrote:
>
>> Hey Robert. Thanks for coming here to offer to clarify any doubts people
>> have regarding Hyperbole.
>>
>> I haven't been interacting with the thread, but I've been lurking about
>> and I've tried Hyperbole in the past, but couldn't precisely figure out
>> its use case in my particular workflow, so I gave up on it.
>>
>> Now, according to your description, the main feature of Hyperbole looks
>> a lot like what Embark [1] does sort of the same thing, albeit in
>> different contexts, complexity (not a bad thing) and workflow. Would you
>> be able to compare them? I think it would help me understand where
>> exactly Hyperbole fits, and what is the problem it tries to solve.
>>
>> [1] https://github.com/oantolin/embark
>>
>> Best regards,
>>
>> --
>> João Pedro de A. Paula
>> IT undergraduate at Universidade Federal do Rio Grande do Norte (UFRN)
>>
>


-- 
The Kafka Pandemic

A blog about science, health, human rights, and misopathy:
https://thekafkapandemic.blogspot.com

Re: Org and Hyperbole

[Ihor Radchenko]

Samuel Wales <samologist@gmail.com> writes:

> is there a mailing list for embark?

AFAIK, embark is developed on GitHub:
https://github.com/oantolin/embark/

Best,
Ihor

Re: Org and Hyperbole

[Samuel Wales]

thanks!  i was aware that it was developed on github, but i do not
know anything about github, and didn't kow if there was a maliing list
in addition.  or are projects given their own mailing lists when they
are formed on github?  or is there an email bidir interface to github?
 or is pretty much absolutely everything for such projects done on
gh's website and you hae to have an account to ask a q?  i might be
asking too much of gh :).


On 7/1/22, Ihor Radchenko <yantar92@gmail.com> wrote:
> Samuel Wales <samologist@gmail.com> writes:
>
>> is there a mailing list for embark?
>
> AFAIK, embark is developed on GitHub:
> https://github.com/oantolin/embark/
>
> Best,
> Ihor
>


-- 
The Kafka Pandemic

A blog about science, health, human rights, and misopathy:
https://thekafkapandemic.blogspot.com

Re: Org and Hyperbole

[Ihor Radchenko]

Samuel Wales <samologist@gmail.com> writes:

> thanks!  i was aware that it was developed on github, but i do not
> know anything about github, and didn't kow if there was a maliing list
> in addition.  or are projects given their own mailing lists when they
> are formed on github?  or is there an email bidir interface to github?
>  or is pretty much absolutely everything for such projects done on
> gh's website and you hae to have an account to ask a q?  i might be
> asking too much of gh :).

Github is not very FSF-friendly. AFAIK, you must have an account to
participate in the discussions. In order to make an account, you also
need to run a non-Free JS.

To post a question, you usually have to open an "issue" on the website.
Though you can leverage Magit to do it for you without browser.
(https://magit.vc/manual/forge/)

Tracking new "issues" is somewhat easier - you can make Github send
emails to you and you can reply to those emails normally - the replies
will show up as "comments" in Github page.

Also, once you created an issue, you can reply by email if you
configured Github to send you email updated.

Best,
Ihor

Re: Org and Hyperbole

[Samuel Wales]

thank you.  that helps me understand.

i probably won't be asking them a q, if i have to sign up and set up a
non-free js in debian or firefox-esr [?].  embark looks interesting
though.


On 7/1/22, Ihor Radchenko <yantar92@gmail.com> wrote:
> Samuel Wales <samologist@gmail.com> writes:
>
>> thanks!  i was aware that it was developed on github, but i do not
>> know anything about github, and didn't kow if there was a maliing list
>> in addition.  or are projects given their own mailing lists when they
>> are formed on github?  or is there an email bidir interface to github?
>>  or is pretty much absolutely everything for such projects done on
>> gh's website and you hae to have an account to ask a q?  i might be
>> asking too much of gh :).
>
> Github is not very FSF-friendly. AFAIK, you must have an account to
> participate in the discussions. In order to make an account, you also
> need to run a non-Free JS.
>
> To post a question, you usually have to open an "issue" on the website.
> Though you can leverage Magit to do it for you without browser.
> (https://magit.vc/manual/forge/)
>
> Tracking new "issues" is somewhat easier - you can make Github send
> emails to you and you can reply to those emails normally - the replies
> will show up as "comments" in Github page.
>
> Also, once you created an issue, you can reply by email if you
> configured Github to send you email updated.
>
> Best,
> Ihor
>


-- 
The Kafka Pandemic

A blog about science, health, human rights, and misopathy:
https://thekafkapandemic.blogspot.com

Re: Org and Hyperbole

[Max Brieiev]

Hi Robert,

Robert Weiner <rsw@gnu.org> writes:

> Oantolin no doubt can speak to Embark much better but my present
> understanding is that it is a toolkit package for generating contextual
> popup or completion menus with a few standard context menus included.
>
> Hyperbole is a much broader personal information management
> environment, one part of which is to turn every common type of
> cross-reference found in buffers from programming identifiers to
> page links into immediately useable hyperlinks with no effort
> or markup on your part (implicit buttons).

I struggle to understand the core difference between Embark and
Hyperbole.

In terms of Embark, the context around point is called /target/. So if
the target is a filename, then the default action is to visit the
file. If the default action is not what you want, then Embark can
present you with a context menu - you can choose amongst the actions
that can be executed on the file, like deleting it or locating it in a
dired buffer.

In terms of Hyperbole, the contextual information is called /implicit
button/. Pressing M-RET on it sounds very much the same as executing
the default action in terms of Embark.

Embark defines the following targets: file, symbol, URL, s-expression,
defun, etc. It seems it is conceptually the same as implicit buttons in
Hyperbole. Is this correct?

Re: Org and Hyperbole

[Ihor Radchenko]

Max Brieiev <max.brieiev@gmail.com> writes:

> Embark defines the following targets: file, symbol, URL, s-expression,
> defun, etc. It seems it is conceptually the same as implicit buttons in
> Hyperbole. Is this correct?

AFAIK, the strength of Hyperbole is that you can easily define custom
targets.

Best,
Ihor

Re: Org and Hyperbole

[Robert Weiner]

And it does highly complex context matching for many common patterns out of the box with no need for customization.

— rsw

> On Jul 7, 2022, at 8:26 AM, Ihor Radchenko <yantar92@gmail.com> wrote:
> 
> Max Brieiev <max.brieiev@gmail.com> writes:
> 
>> Embark defines the following targets: file, symbol, URL, s-expression,
>> defun, etc. It seems it is conceptually the same as implicit buttons in
>> Hyperbole. Is this correct?
> 
> AFAIK, the strength of Hyperbole is that you can easily define custom
> targets.
> 
> Best,
> Ihor

Re: Org and Hyperbole

[Robert Weiner]

Just noting that we have seen this and will have a look.

-- rsw

> On Jul 16, 2022, at 7:16 PM, Robert Weiner <rswgnu@gmail.com> wrote:
> 
> And it does highly complex context matching for many common patterns out of the box with no need for customization.
> 
> — rsw
> 
>> On Jul 7, 2022, at 8:26 AM, Ihor Radchenko <yantar92@gmail.com> wrote:
>> 
>> Max Brieiev <max.brieiev@gmail.com> writes:
>> 
>>> Embark defines the following targets: file, symbol, URL, s-expression,
>>> defun, etc. It seems it is conceptually the same as implicit buttons in
>>> Hyperbole. Is this correct?
>> 
>> AFAIK, the strength of Hyperbole is that you can easily define custom
>> targets.
>> 
>> Best,
>> Ihor

Re: Org and Hyperbole

[David Masterson]

Robert Weiner <rsw@gnu.org> writes:

> I am happy to answer questions and discuss ways we can make Hyperbole
> and Org work even better together; one direct question per message
> would typically work best.  Responses may take awhile as my schedule
> makes it difficult to keep up with high volume mailing lists but if
> you cc: rsw@gnu.org, I'll likely see your message faster and respond.

Hi Robert,

*LONG* time since we last talked (~1990?).  Good to see that Hyperbole
is still being developed -- it was very interesting even back then.  A
couple of questions:

1. Is OO-Browser still a part of Hyperbole and still developed?

2. Is there a discussion on how to run a KOutline out to Latex and PDF
thru (say) Org export in a way that allows you to take advantage of
Latex packages or even mix-in Org markup?

-- 
David Masterson

Re: Org and Hyperbole

[Robert Weiner]

Hi David:

Great to see you here too.  We could use you on extended Hyperbole documentation if you ever get into it.

1.  The OO-Browser was part of InfoDock, my IDE framework atop XEmacs.  I have updated it for GNU Emacs but never get the time to finish it enough to put it out there again as Hyperbole fills my spare time.  But reach out directly if you want to discuss.

2. We have not yet integrated org-export with the Koutliner but want to.  You can convert a Koutline to a star outline and call it an Org file, so it wouldn’t be too hard.  It has its own builtin export to HTML from which you could get to pdf as well, I imagine.

-- Bob

> On Jun 25, 2022, at 3:07 PM, David Masterson <dsmasterson@gmail.com> wrote:
> 
> Robert Weiner <rsw@gnu.org> writes:
> 
>> I am happy to answer questions and discuss ways we can make Hyperbole
>> and Org work even better together; one direct question per message
>> would typically work best.  Responses may take awhile as my schedule
>> makes it difficult to keep up with high volume mailing lists but if
>> you cc: rsw@gnu.org, I'll likely see your message faster and respond.
> 
> Hi Robert,
> 
> *LONG* time since we last talked (~1990?).  Good to see that Hyperbole
> is still being developed -- it was very interesting even back then.  A
> couple of questions:
> 
> 1. Is OO-Browser still a part of Hyperbole and still developed?
> 
> 2. Is there a discussion on how to run a KOutline out to Latex and PDF
> thru (say) Org export in a way that allows you to take advantage of
> Latex packages or even mix-in Org markup?
> 
> -- 
> David Masterson

Re: Org and Hyperbole

[David Masterson]

Robert Weiner <rswgnu@gmail.com> writes:

> Great to see you here too.  We could use you on extended Hyperbole
> documentation if you ever get into it.

Thanks, my hands don't type well anymore or I might've considered it,

> 1.  The OO-Browser was part of InfoDock, my IDE framework atop XEmacs.
> I have updated it for GNU Emacs but never get the time to finish it
> enough to put it out there again as Hyperbole fills my spare time.
> But reach out directly if you want to discuss.

Oh! I forgot about Infodock!  OO-Browser would be good for the
developers in the crowd.  Perhaps the new interest of Hyperbole v8 will
spur interest in OO-Browsr.

> 2. We have not yet integrated org-export with the Koutliner but want
> to.  You can convert a Koutline to a star outline and call it an Org
> file, so it wouldn’t be too hard.  It has its own builtin export to
> HTML from which you could get to pdf as well, I imagine.

I didn't see in the documentation on how to convert a Koutline to a star
outline.  That would be useful to me (especially if you could go the
other way as well).  With this capability, it shouldn't be too hard
write a standard file header in (say) commented Latex that could be
included in the file (via a post-hook) which could then be run through
org-export via org-publish.

-- 
David Masterson

Re: Org and Hyperbole

[Robert Weiner]

[-- Attachment #1: Type: text/plain, Size: 1925 bytes --]

On Sat, Jun 25, 2022 at 5:18 PM David Masterson <dsmasterson@gmail.com>
wrote:

> Robert Weiner <rswgnu@gmail.com> writes:
>
> > Great to see you here too.  We could use you on extended Hyperbole
> > documentation if you ever get into it.
>
> Thanks, my hands don't type well anymore or I might've considered it,
>
> > 1.  The OO-Browser was part of InfoDock, my IDE framework atop XEmacs.
> > I have updated it for GNU Emacs but never get the time to finish it
> > enough to put it out there again as Hyperbole fills my spare time.
> > But reach out directly if you want to discuss.
>
> Oh! I forgot about Infodock!  OO-Browser would be good for the
> developers in the crowd.  Perhaps the new interest of Hyperbole v8 will
> spur interest in OO-Browsr.
>

I know it would be good to revive it.  Just need more time than I have now.

>
> > 2. We have not yet integrated org-export with the Koutliner but want
> > to.  You can convert a Koutline to a star outline and call it an Org
> > file, so it wouldn’t be too hard.  It has its own builtin export to
> > HTML from which you could get to pdf as well, I imagine.
>
> I didn't see in the documentation on how to convert a Koutline to a star
> outline.  That would be useful to me (especially if you could go the
> other way as well).  With this capability, it shouldn't be too hard
> write a standard file header in (say) commented Latex that could be
> included in the file (via a post-hook) which could then be run through
> org-export via org-publish.
>

Just use {M-x kimport:star-outline RET} when in an Org or Emacs outline
buffer to create a Koutline from them.

I just checked and there doesn't seem to be an equivalent
kexport:star-outline but you could probably write it without too much
effort using the existing kview:map-siblings function and starting from the
first cell.

-- rsw


> --
> David Masterson
>

[-- Attachment #2: Type: text/html, Size: 3364 bytes --]

Re: Org and Hyperbole

[Jean Louis]

* Robert Weiner <rswgnu@gmail.com> [2022-06-25 23:52]:
> 2. We have not yet integrated org-export with the Koutliner but want
> to.  You can convert a Koutline to a star outline and call it an Org
> file, so it wouldn’t be too hard.  It has its own builtin export to
> HTML from which you could get to pdf as well, I imagine.

Kotl should not depend of the HTML template.

Kotl shall have possible export without headers, and styles. It would
be best if style is built in the lines, and not part of the <head>
section.

That way kotl would be embeddable in various HTML templates. 

-- 
Jean

Take action in Free Software Foundation campaigns:
https://www.fsf.org/campaigns

In support of Richard M. Stallman
https://stallmansupport.org/

Re: Org and Hyperbole

[Robert Weiner]

[-- Attachment #1: Type: text/plain, Size: 1036 bytes --]

Another good thought.  Anyone can add an embeddable export of Koutlines; I
don't think we'll find time to do that in the mainline development branch
though.

On Tue, Sep 27, 2022 at 10:45 AM Jean Louis <bugs@gnu.support> wrote:

> * Robert Weiner <rswgnu@gmail.com> [2022-06-25 23:52]:
> > 2. We have not yet integrated org-export with the Koutliner but want
> > to.  You can convert a Koutline to a star outline and call it an Org
> > file, so it wouldn’t be too hard.  It has its own builtin export to
> > HTML from which you could get to pdf as well, I imagine.
>
> Kotl should not depend of the HTML template.
>
> Kotl shall have possible export without headers, and styles. It would
> be best if style is built in the lines, and not part of the <head>
> section.
>
> That way kotl would be embeddable in various HTML templates.
>
> --
> Jean
>
> Take action in Free Software Foundation campaigns:
> https://www.fsf.org/campaigns
>
> In support of Richard M. Stallman
> https://stallmansupport.org/
>

[-- Attachment #2: Type: text/html, Size: 1632 bytes --]

Re: Org and Hyperbole

[Jean Louis]

* Robert Weiner <rsw@gnu.org> [2022-10-04 09:29]:
> Another good thought.  Anyone can add an embeddable export of Koutlines; I
> don't think we'll find time to do that in the mainline development branch
> though.

Creating HTML export that is messy has greater impact on people, no
matter of popularity of the package. 

KOTL may be said to be specialized lightweight markup language as it
has export to HTML and various features. Thus authors shall put care
on proper HTML and including on the fact that all lightweight markup
languages allow export without headers and footers, for the reason to
insert the information into ready HTML templates.

Verify it here: https://validator.w3.org/nu/#file
by using KOTL EXAMPLE:


    Error: The character encoding was not declared. Proceeding using windows-1252.

    Error: Start tag seen without seeing a doctype first. Expected <!DOCTYPE html>.

    From line 1, column 1; to line 1, column 6

    <html><head>

    Error: Element head is missing a required instance of child element title.

    From line 3, column 1; to line 3, column 12

    l><head>↩↩<a id="top"></a><a

    Content model for element head:
        If the document is an iframe srcdoc document or if title information is available from a higher-level protocol: Zero or more elements of metadata content, of which no more than one is a title element and no more than one is a base element.
        Otherwise: One or more elements of metadata content, of which exactly one is a title element and no more than one is a base element.

    Error: Element title not allowed as child of element body in this context. (Suppressing further errors from this subtree.)

    From line 4, column 1; to line 4, column 7

    "k0"></a>↩<title>EXAMPL

    Contexts in which element title may be used:
        In a head element containing no other title elements.
    Content model for element body:
        Flow content.

    Error: No space between attributes.

    At line 6, column 6

    outliner.↩See "(hyperbole)Kout

    Error: Quote " in attribute name. Probable cause: Matching quote missing somewhere earlier.

    At line 6, column 26

    rbole)Koutliner" for more info

    Error: Quote " in attribute name. Probable cause: Matching quote missing somewhere earlier.

    At line 6, column 49

    re information.">↩<meta name="

    Warning: Attribute (hyperbole)koutliner" is not serializable as XML 1.0.

    From line 5, column 1; to line 6, column 50

    E</title>↩<meta id="description" content="Created by Hyperbole's outliner.↩See "(hyperbole)Koutliner" for more information.">↩<meta

    Warning: Attribute information." is not serializable as XML 1.0.

    From line 5, column 1; to line 6, column 50

    E</title>↩<meta id="description" content="Created by Hyperbole's outliner.↩See "(hyperbole)Koutliner" for more information.">↩<meta

    Error: Attribute (hyperbole)koutliner" not allowed on element meta at this point.

    From line 5, column 1; to line 6, column 50

    E</title>↩<meta id="description" content="Created by Hyperbole's outliner.↩See "(hyperbole)Koutliner" for more information.">↩<meta

    Attributes for element meta:
        Global attributes
        name — Metadata name
        http-equiv — Pragma directive
        content — Value of the element
        charset — Character encoding declaration
        media — Applicable media

    Error: Attribute for not allowed on element meta at this point.

    From line 5, column 1; to line 6, column 50

    E</title>↩<meta id="description" content="Created by Hyperbole's outliner.↩See "(hyperbole)Koutliner" for more information.">↩<meta

    Attributes for element meta:
        Global attributes
        name — Metadata name
        http-equiv — Pragma directive
        content — Value of the element
        charset — Character encoding declaration
        media — Applicable media

    Error: Attribute more not allowed on element meta at this point.

    From line 5, column 1; to line 6, column 50

    E</title>↩<meta id="description" content="Created by Hyperbole's outliner.↩See "(hyperbole)Koutliner" for more information.">↩<meta

    Attributes for element meta:
        Global attributes
        name — Metadata name
        http-equiv — Pragma directive
        content — Value of the element
        charset — Character encoding declaration
        media — Applicable media

    Error: Attribute information." not allowed on element meta at this point.

    From line 5, column 1; to line 6, column 50

    E</title>↩<meta id="description" content="Created by Hyperbole's outliner.↩See "(hyperbole)Koutliner" for more information.">↩<meta

    Attributes for element meta:
        Global attributes
        name — Metadata name
        http-equiv — Pragma directive
        content — Value of the element
        charset — Character encoding declaration
        media — Applicable media

    Error: Element meta is missing one or more of the following attributes: itemprop, property.

    From line 5, column 1; to line 6, column 50

    E</title>↩<meta id="description" content="Created by Hyperbole's outliner.↩See "(hyperbole)Koutliner" for more information.">↩<meta

    Attributes for element meta:
        Global attributes
        name — Metadata name
        http-equiv — Pragma directive
        content — Value of the element
        charset — Character encoding declaration
        media — Applicable media

    Error: Attribute name not allowed on element meta at this point.

    From line 7, column 1; to line 7, column 68

    mation.">↩<meta name="viewport" content="width=device-width, initial-scale=1"><link 

    Attributes for element meta:
        Global attributes
        name — Metadata name
        http-equiv — Pragma directive
        content — Value of the element
        charset — Character encoding declaration
        media — Applicable media

    Error: Element meta is missing one or more of the following attributes: itemprop, property.

    From line 7, column 1; to line 7, column 68

    mation.">↩<meta name="viewport" content="width=device-width, initial-scale=1"><link 

    Attributes for element meta:
        Global attributes
        name — Metadata name
        http-equiv — Pragma directive
        content — Value of the element
        charset — Character encoding declaration
        media — Applicable media

    Error: Element style not allowed as child of element body in this context. (Suppressing further errors from this subtree.)

    From line 8, column 1; to line 8, column 7

    min.css">↩<style>↩↩butt

    Contexts in which element style may be used:
        Where metadata content is expected.
        In a noscript element that is a child of a head element.
    Content model for element body:
        Flow content.

    Error: Stray end tag head.

    From line 45, column 1; to line 45, column 7

    ↩</style>↩</head>↩↩<bod

    Error: Start tag body seen but an element of the same type was already open.

    From line 47, column 1; to line 47, column 24

    ↩</head>↩↩<body BGCOLOR="#FFFFFF">↩↩<h1>

    Fatal Error: Cannot recover after last error. Any further errors will be ignored.

    From line 47, column 1; to line 47, column 24

    ↩</head>↩↩<body BGCOLOR="#FFFFFF">↩↩<h1>
-- 
Jean

Take action in Free Software Foundation campaigns:
https://www.fsf.org/campaigns

In support of Richard M. Stallman
https://stallmansupport.org/

Re: bug#58371: Org and Hyperbole

[Bob Weiner]

This one too.  Just running the output of the Koutline EXAMPLE.kotl HTML
export through the validator mentioned and resolving the issues in the
code that spits out the HTML:  kexport:html.

I'll add to the todo list for whenever you have time.

Cheers,

Bob

Jean Louis <bugs@gnu.support> writes:

> * Robert Weiner <rsw@gnu.org> [2022-10-04 09:29]:
>> Another good thought.  Anyone can add an embeddable export of Koutlines; I
>> don't think we'll find time to do that in the mainline development branch
>> though.
>
> Creating HTML export that is messy has greater impact on people, no
> matter of popularity of the package. 
>
> KOTL may be said to be specialized lightweight markup language as it
> has export to HTML and various features. Thus authors shall put care
> on proper HTML and including on the fact that all lightweight markup
> languages allow export without headers and footers, for the reason to
> insert the information into ready HTML templates.
>
> Verify it here: https://validator.w3.org/nu/#file
> by using KOTL EXAMPLE:
>
>
>     Error: The character encoding was not declared. Proceeding using windows-1252.
>
>     Error: Start tag seen without seeing a doctype first. Expected <!DOCTYPE html>.
>
>     From line 1, column 1; to line 1, column 6
>
>     <html><head>
>
>     Error: Element head is missing a required instance of child element title.
>
>     From line 3, column 1; to line 3, column 12
>
>     l><head>↩↩<a id="top"></a><a
>
>     Content model for element head:
>         If the document is an iframe srcdoc document or if title information is available from a higher-level protocol: Zero or more elements of metadata content, of which no more than one is a title element and no more than one is a base element.
>         Otherwise: One or more elements of metadata content, of which exactly one is a title element and no more than one is a base element.
>
>     Error: Element title not allowed as child of element body in this context. (Suppressing further errors from this subtree.)
>
>     From line 4, column 1; to line 4, column 7
>
>     "k0"></a>↩<title>EXAMPL
>
>     Contexts in which element title may be used:
>         In a head element containing no other title elements.
>     Content model for element body:
>         Flow content.
>
>     Error: No space between attributes.
>
>     At line 6, column 6
>
>     outliner.↩See "(hyperbole)Kout
>
>     Error: Quote " in attribute name. Probable cause: Matching quote missing somewhere earlier.
>
>     At line 6, column 26
>
>     rbole)Koutliner" for more info
>
>     Error: Quote " in attribute name. Probable cause: Matching quote missing somewhere earlier.
>
>     At line 6, column 49
>
>     re information.">↩<meta name="
>
>     Warning: Attribute (hyperbole)koutliner" is not serializable as XML 1.0.
>
>     From line 5, column 1; to line 6, column 50
>
>     E</title>↩<meta id="description" content="Created by Hyperbole's outliner.↩See "(hyperbole)Koutliner" for more information.">↩<meta
>
>     Warning: Attribute information." is not serializable as XML 1.0.
>
>     From line 5, column 1; to line 6, column 50
>
>     E</title>↩<meta id="description" content="Created by Hyperbole's outliner.↩See "(hyperbole)Koutliner" for more information.">↩<meta
>
>     Error: Attribute (hyperbole)koutliner" not allowed on element meta at this point.
>
>     From line 5, column 1; to line 6, column 50
>
>     E</title>↩<meta id="description" content="Created by Hyperbole's outliner.↩See "(hyperbole)Koutliner" for more information.">↩<meta
>
>     Attributes for element meta:
>         Global attributes
>         name — Metadata name
>         http-equiv — Pragma directive
>         content — Value of the element
>         charset — Character encoding declaration
>         media — Applicable media
>
>     Error: Attribute for not allowed on element meta at this point.
>
>     From line 5, column 1; to line 6, column 50
>
>     E</title>↩<meta id="description" content="Created by Hyperbole's outliner.↩See "(hyperbole)Koutliner" for more information.">↩<meta
>
>     Attributes for element meta:
>         Global attributes
>         name — Metadata name
>         http-equiv — Pragma directive
>         content — Value of the element
>         charset — Character encoding declaration
>         media — Applicable media
>
>     Error: Attribute more not allowed on element meta at this point.
>
>     From line 5, column 1; to line 6, column 50
>
>     E</title>↩<meta id="description" content="Created by Hyperbole's outliner.↩See "(hyperbole)Koutliner" for more information.">↩<meta
>
>     Attributes for element meta:
>         Global attributes
>         name — Metadata name
>         http-equiv — Pragma directive
>         content — Value of the element
>         charset — Character encoding declaration
>         media — Applicable media
>
>     Error: Attribute information." not allowed on element meta at this point.
>
>     From line 5, column 1; to line 6, column 50
>
>     E</title>↩<meta id="description" content="Created by Hyperbole's outliner.↩See "(hyperbole)Koutliner" for more information.">↩<meta
>
>     Attributes for element meta:
>         Global attributes
>         name — Metadata name
>         http-equiv — Pragma directive
>         content — Value of the element
>         charset — Character encoding declaration
>         media — Applicable media
>
>     Error: Element meta is missing one or more of the following attributes: itemprop, property.
>
>     From line 5, column 1; to line 6, column 50
>
>     E</title>↩<meta id="description" content="Created by Hyperbole's outliner.↩See "(hyperbole)Koutliner" for more information.">↩<meta
>
>     Attributes for element meta:
>         Global attributes
>         name — Metadata name
>         http-equiv — Pragma directive
>         content — Value of the element
>         charset — Character encoding declaration
>         media — Applicable media
>
>     Error: Attribute name not allowed on element meta at this point.
>
>     From line 7, column 1; to line 7, column 68
>
>     mation.">↩<meta name="viewport" content="width=device-width, initial-scale=1"><link 
>
>     Attributes for element meta:
>         Global attributes
>         name — Metadata name
>         http-equiv — Pragma directive
>         content — Value of the element
>         charset — Character encoding declaration
>         media — Applicable media
>
>     Error: Element meta is missing one or more of the following attributes: itemprop, property.
>
>     From line 7, column 1; to line 7, column 68
>
>     mation.">↩<meta name="viewport" content="width=device-width, initial-scale=1"><link 
>
>     Attributes for element meta:
>         Global attributes
>         name — Metadata name
>         http-equiv — Pragma directive
>         content — Value of the element
>         charset — Character encoding declaration
>         media — Applicable media
>
>     Error: Element style not allowed as child of element body in this context. (Suppressing further errors from this subtree.)
>
>     From line 8, column 1; to line 8, column 7
>
>     min.css">↩<style>↩↩butt
>
>     Contexts in which element style may be used:
>         Where metadata content is expected.
>         In a noscript element that is a child of a head element.
>     Content model for element body:
>         Flow content.
>
>     Error: Stray end tag head.
>
>     From line 45, column 1; to line 45, column 7
>
>     ↩</style>↩</head>↩↩<bod
>
>     Error: Start tag body seen but an element of the same type was already open.
>
>     From line 47, column 1; to line 47, column 24
>
>     ↩</head>↩↩<body BGCOLOR="#FFFFFF">↩↩<h1>
>
>     Fatal Error: Cannot recover after last error. Any further errors will be ignored.
>
>     From line 47, column 1; to line 47, column 24
>
>     ↩</head>↩↩<body BGCOLOR="#FFFFFF">↩↩<h1>

Re: bug#58371: Org and Hyperbole

[Mats Lidell]

> Jean Louis writes:
> * Robert Weiner <rsw@gnu.org> [2022-10-04 09:29]:
> > Another good thought.  Anyone can add an embeddable export of Koutlines; I
> > don't think we'll find time to do that in the mainline development branch
> > though.
>
> Creating HTML export that is messy has greater impact on people, no
> matter of popularity of the package. 
>
> KOTL may be said to be specialized lightweight markup language as it
> has export to HTML and various features. Thus authors shall put care
> on proper HTML and including on the fact that all lightweight markup
> languages allow export without headers and footers, for the reason to
> insert the information into ready HTML templates.
>
> Verify it here: https://validator.w3.org/nu/#file
> by using KOTL EXAMPLE:

Thanks for the report. The export should now produce HTML that passes the validation. It is available at elpa-devel.

Work on exporting embedded HTML still remains.

%% Mats

Re: Org and Hyperbole

[Siva Swaminathan]

Hello,

I only recently became aware of Hyperbole (through Bob's demo video
available on Youtube), and came across this thread while googling to
find more information about Hyperbole. I feel that some of the
questions raised here about Hyperbole sound akin to the story of five
blind men feeling the elephant, so I humbly offer my perspective on
what I consider to be the key underlying ideas. Forgive me if I'm
stating the obvious, and I also don't know whether Hyperbole as
currently implemented does exactly all this :-)

I'd like to think of the key idea of Hyperbole as converting text in
buffers into *objects* (aka "buttons") by attaching *behavior* to them.
The two actions provided by convention could be thought of as akin to
the left-click and right-click which one is familiar with in
contemporary GUIs, in this case respectively bound to methods for "do
(by default)" and "show metadata". Supporting more
behaviors/methods/messages for user-invocation is an obvious next idea
(if not already so).

The above system would be of quite limited composability if it required
objects to be defined explicitly -- because most buffers one operates
on are generated without awareness of Hyperbole (imagine the pain of
everything needing to conform to something like a Hyperbole
framework/protocol!). The cleverness behind implicit buttons is that
one can opportunistically use common conventions as "schemas" to "parse
/ deserialize" the contents which make up an object from any buffer (in
this case via regexps) and attach corresponding (expected) behaviors to
them! Because of the highly structured nature of such data, even if
embedded in a stream of plain text, it can typically be parsed
correctly without needing explicit type annotations. The behaviors
could presumably depend not just the object, but also the active modes,
environment variables, etc.

Here are a few made-up example use cases (hand-waving over details):

1. I might embed phrases such as "bug:123" in my code / emails / org
task management and have behaviors that respectively fetch the bug
report / open some URL in a browser / or update the TODO status based
on the bug status, as desired. This would help me interface
conveniently with a bespoke bug-tracking tool.

2. On encountering Goodreads links in my reading list org file, I could
have a behavior to parse the contents of the webpage and extract
desired metadata to add to the item properties (or an entry to some org
table).

3. Linking by immutable block identifiers (and fast lookup) of course
enables a lot of PKM workflows that have recently become popular (with
the addition of bidirectional links).

Other aspects such as menus generated from button files seem like
convenient affordances bolted on to make up the UI of the system. I
still need to wrap my mind around these, but I wonder whether there
might be opportunities to compose with other ecosystem tools which have
pioneered some nice UI ideas eg. transient menus, hydras, interactive
selection lists, etc. But that's a discussion for the Hyperbole mailing
list.


From a first impression, I'm really impressed, and also surprised that
Hyperbole is not more popular. Much gratitude to the contributors for a
nifty tool, and a fascinating design perspective.

Best regards,
Siva
http://sivark.me

Re: Org and Hyperbole

[tomas]

[-- Attachment #1: Type: text/plain, Size: 493 bytes --]

On Sat, Jun 25, 2022 at 11:37:55PM -0700, Siva Swaminathan wrote:
> Hello,

> [...] I feel that some of the
> questions raised here about Hyperbole sound akin to the story of five
> blind men feeling the elephant [...]

The nice thing about that kind of situation is that it only can improve
by adding in a sixth blind man ;-)

Thank you from someone "too swamped right now to try to tackle another
whole peradigm, but still enormously curious about this thing".

Cheers
-- 
t

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 195 bytes --]

Re: Org and Hyperbole

[David Masterson]

<tomas@tuxteam.de> writes:

> On Sat, Jun 25, 2022 at 11:37:55PM -0700, Siva Swaminathan wrote:

>> [...] I feel that some of the
>> questions raised here about Hyperbole sound akin to the story of five
>> blind men feeling the elephant [...]
>
> The nice thing about that kind of situation is that it only can improve
> by adding in a sixth blind man ;-)
>
> Thank you from someone "too swamped right now to try to tackle another
> whole peradigm, but still enormously curious about this thing".

Yup!  I hope a new generation of users will sprout.  As I mentioned to
Bob, I think OO-Browser will bring programmers in to help expand
Hyperbole as well as OO-Browser.

-- 
David Masterson

Re: Org and Hyperbole

[indieterminacy]

On 26-06-2022 22:03, David Masterson wrote:
> <tomas@tuxteam.de> writes:
> 
>> On Sat, Jun 25, 2022 at 11:37:55PM -0700, Siva Swaminathan wrote:
> 
>>> [...] I feel that some of the
>>> questions raised here about Hyperbole sound akin to the story of five
>>> blind men feeling the elephant [...]
>> 
>> The nice thing about that kind of situation is that it only can 
>> improve
>> by adding in a sixth blind man ;-)
>> 
>> Thank you from someone "too swamped right now to try to tackle another
>> whole peradigm, but still enormously curious about this thing".
> 
> Yup!  I hope a new generation of users will sprout.  As I mentioned to
> Bob, I think OO-Browser will bring programmers in to help expand
> Hyperbole as well as OO-Browser.

Ive seen references to OO-Browser (documentation, wistfulness) but hadnt 
come across how to try it.

Id interpreted it as being a victim of bitrot and lost in the sands of 
time (and is resting next to a genie lamp and hardback documentation for 
Xemacs).

Is there a working version about for GNU Emacs?


-- 
Jonathan McHugh
indieterminacy@libre.brussels

Re: Org and Hyperbole

[Robert Weiner]

[-- Attachment #1: Type: text/plain, Size: 2026 bytes --]

Hi Jonathan:

Yes, I no longer have time to maintain it and based on quality standards
don't wish to re-release it unless one or more highly experienced Emacs
package developers want to take it on, as it is a good size package.  Such
a person would have to have developed significant Emacs packages like Org
or Hyperbole and have reasonable time to answer questions and make updates
as issues and requests came in.  Familiarity with a multitude of
object-oriented languages would also be useful.  Such volunteers are
welcome.  Please don't offer if you have the desire but not the experience.

In the event no such party appears, when I do find time to make some
necessary updates for a release, I'll do my best to get to it and then make
a release that you can check out.

-- rsw

On Sun, Jun 26, 2022 at 4:28 PM indieterminacy
<indieterminacy@libre.brussels> wrote:

>
> On 26-06-2022 22:03, David Masterson wrote:
> > <tomas@tuxteam.de> writes:
> >
> >> On Sat, Jun 25, 2022 at 11:37:55PM -0700, Siva Swaminathan wrote:
> >
> >>> [...] I feel that some of the
> >>> questions raised here about Hyperbole sound akin to the story of five
> >>> blind men feeling the elephant [...]
> >>
> >> The nice thing about that kind of situation is that it only can
> >> improve
> >> by adding in a sixth blind man ;-)
> >>
> >> Thank you from someone "too swamped right now to try to tackle another
> >> whole peradigm, but still enormously curious about this thing".
> >
> > Yup!  I hope a new generation of users will sprout.  As I mentioned to
> > Bob, I think OO-Browser will bring programmers in to help expand
> > Hyperbole as well as OO-Browser.
>
> Ive seen references to OO-Browser (documentation, wistfulness) but hadnt
> come across how to try it.
>
> Id interpreted it as being a victim of bitrot and lost in the sands of
> time (and is resting next to a genie lamp and hardback documentation for
> Xemacs).
>
> Is there a working version about for GNU Emacs?
>
>
> --
> Jonathan McHugh
> indieterminacy@libre.brussels
>
>

[-- Attachment #2: Type: text/html, Size: 3085 bytes --]

Re: Org and Hyperbole

[David Masterson]

Robert Weiner <rsw@gnu.org> writes:

> Yes, I no longer have time to maintain it and based on quality
> standards don't wish to re-release it unless one or more highly
> experienced Emacs package developers want to take it on, as it is a
> good size package.  Such a person would have to have developed
> significant Emacs packages like Org or Hyperbole and have reasonable
> time to answer questions and make updates as issues and requests came
> in.  Familiarity with a multitude of object-oriented languages would
> also be useful.  Such volunteers are welcome.  Please don't offer if
> you have the desire but not the experience.
>
> In the event no such party appears, when I do find time to make some
> necessary updates for a release, I'll do my best to get to it and then
> make a release that you can check out.

Ah! I saw your old source code repositories for OO-Browser on
Sourceforge and Savanah, but didn't look close enough to see they were
significantly out-of-date.  Warning to others that may go looking.

-- 
David Masterson

Re: Org and Hyperbole

[Robert Weiner]

[-- Attachment #1: Type: text/plain, Size: 3826 bytes --]

Hi Siva:

Yes, I think you have a good handle on the concepts behind Hyperbole
buttons and additional Action Key contexts.  Beyond that, there is also the
Koutliner, HyRolo and HyControl in Hyperbole as you grow into it.  Look
forward to seeing some of the implicit button types you create for your own
use.

-- rsw

On Sun, Jun 26, 2022 at 2:37 AM Siva Swaminathan <siva.rk.sw@gmail.com>
wrote:

> Hello,
>
> I only recently became aware of Hyperbole (through Bob's demo video
> available on Youtube), and came across this thread while googling to
> find more information about Hyperbole. I feel that some of the
> questions raised here about Hyperbole sound akin to the story of five
> blind men feeling the elephant, so I humbly offer my perspective on
> what I consider to be the key underlying ideas. Forgive me if I'm
> stating the obvious, and I also don't know whether Hyperbole as
> currently implemented does exactly all this :-)
>
> I'd like to think of the key idea of Hyperbole as converting text in
> buffers into *objects* (aka "buttons") by attaching *behavior* to them.
> The two actions provided by convention could be thought of as akin to
> the left-click and right-click which one is familiar with in
> contemporary GUIs, in this case respectively bound to methods for "do
> (by default)" and "show metadata". Supporting more
> behaviors/methods/messages for user-invocation is an obvious next idea
> (if not already so).
>
> The above system would be of quite limited composability if it required
> objects to be defined explicitly -- because most buffers one operates
> on are generated without awareness of Hyperbole (imagine the pain of
> everything needing to conform to something like a Hyperbole
> framework/protocol!). The cleverness behind implicit buttons is that
> one can opportunistically use common conventions as "schemas" to "parse
> / deserialize" the contents which make up an object from any buffer (in
> this case via regexps) and attach corresponding (expected) behaviors to
> them! Because of the highly structured nature of such data, even if
> embedded in a stream of plain text, it can typically be parsed
> correctly without needing explicit type annotations. The behaviors
> could presumably depend not just the object, but also the active modes,
> environment variables, etc.
>
> Here are a few made-up example use cases (hand-waving over details):
>
> 1. I might embed phrases such as "bug:123" in my code / emails / org
> task management and have behaviors that respectively fetch the bug
> report / open some URL in a browser / or update the TODO status based
> on the bug status, as desired. This would help me interface
> conveniently with a bespoke bug-tracking tool.
>
> 2. On encountering Goodreads links in my reading list org file, I could
> have a behavior to parse the contents of the webpage and extract
> desired metadata to add to the item properties (or an entry to some org
> table).
>
> 3. Linking by immutable block identifiers (and fast lookup) of course
> enables a lot of PKM workflows that have recently become popular (with
> the addition of bidirectional links).
>
> Other aspects such as menus generated from button files seem like
> convenient affordances bolted on to make up the UI of the system. I
> still need to wrap my mind around these, but I wonder whether there
> might be opportunities to compose with other ecosystem tools which have
> pioneered some nice UI ideas eg. transient menus, hydras, interactive
> selection lists, etc. But that's a discussion for the Hyperbole mailing
> list.
>
>
> From a first impression, I'm really impressed, and also surprised that
> Hyperbole is not more popular. Much gratitude to the contributors for a
> nifty tool, and a fascinating design perspective.
>
> Best regards,
> Siva
> http://sivark.me
>
>

[-- Attachment #2: Type: text/html, Size: 4839 bytes --]

Re: Org and Hyperbole

[Robert Weiner]

[-- Attachment #1: Type: text/plain, Size: 4147 bytes --]

Hi Siva:

(Sorry, I can't read this list too often so I miss some of these great
messages).

That is a very nice explanation of the power of implicit buttons.  Imagine
being able to ignore having to fully parse documents and instead just
describing the patterns of interest and what to do with them using simple
mechanisms (see Hyperbole's defal, defil and defib macros) and then having
live hypertext in such documents with no formatting changes.  Hyperbole
makes this quick and easy.

We hope more people will give it a spin and get an understanding of what
they can do with it as you have, especially in tandem with Org mode.

-- rsw

On Sun, Jun 26, 2022 at 2:37 AM Siva Swaminathan <siva.rk.sw@gmail.com>
wrote:

> Hello,
>
> I only recently became aware of Hyperbole (through Bob's demo video
> available on Youtube), and came across this thread while googling to
> find more information about Hyperbole. I feel that some of the
> questions raised here about Hyperbole sound akin to the story of five
> blind men feeling the elephant, so I humbly offer my perspective on
> what I consider to be the key underlying ideas. Forgive me if I'm
> stating the obvious, and I also don't know whether Hyperbole as
> currently implemented does exactly all this :-)
>
> I'd like to think of the key idea of Hyperbole as converting text in
> buffers into *objects* (aka "buttons") by attaching *behavior* to them.
> The two actions provided by convention could be thought of as akin to
> the left-click and right-click which one is familiar with in
> contemporary GUIs, in this case respectively bound to methods for "do
> (by default)" and "show metadata". Supporting more
> behaviors/methods/messages for user-invocation is an obvious next idea
> (if not already so).
>
> The above system would be of quite limited composability if it required
> objects to be defined explicitly -- because most buffers one operates
> on are generated without awareness of Hyperbole (imagine the pain of
> everything needing to conform to something like a Hyperbole
> framework/protocol!). The cleverness behind implicit buttons is that
> one can opportunistically use common conventions as "schemas" to "parse
> / deserialize" the contents which make up an object from any buffer (in
> this case via regexps) and attach corresponding (expected) behaviors to
> them! Because of the highly structured nature of such data, even if
> embedded in a stream of plain text, it can typically be parsed
> correctly without needing explicit type annotations. The behaviors
> could presumably depend not just the object, but also the active modes,
> environment variables, etc.
>
> Here are a few made-up example use cases (hand-waving over details):
>
> 1. I might embed phrases such as "bug:123" in my code / emails / org
> task management and have behaviors that respectively fetch the bug
> report / open some URL in a browser / or update the TODO status based
> on the bug status, as desired. This would help me interface
> conveniently with a bespoke bug-tracking tool.
>
> 2. On encountering Goodreads links in my reading list org file, I could
> have a behavior to parse the contents of the webpage and extract
> desired metadata to add to the item properties (or an entry to some org
> table).
>
> 3. Linking by immutable block identifiers (and fast lookup) of course
> enables a lot of PKM workflows that have recently become popular (with
> the addition of bidirectional links).
>
> Other aspects such as menus generated from button files seem like
> convenient affordances bolted on to make up the UI of the system. I
> still need to wrap my mind around these, but I wonder whether there
> might be opportunities to compose with other ecosystem tools which have
> pioneered some nice UI ideas eg. transient menus, hydras, interactive
> selection lists, etc. But that's a discussion for the Hyperbole mailing
> list.
>
>
> From a first impression, I'm really impressed, and also surprised that
> Hyperbole is not more popular. Much gratitude to the contributors for a
> nifty tool, and a fascinating design perspective.
>
> Best regards,
> Siva
> http://sivark.me
>
>

[-- Attachment #2: Type: text/html, Size: 5465 bytes --]

Re: Org and Hyperbole

[Fraga, Eric]

Robert,

just one quick comment and question (maybe the documentation covers
this; if so, apologies): when I tried hyperbole years ago, the annoying
thing was that it took over C-h.  My muscle memory after decades of
Emacs use was disturbed significantly as I use C-h (for Emacs help) all
the time.

thank you,
eric

-- 
: Eric S Fraga, with org release_9.5.4-605-g0ed0de in Emacs 29.0.50

Re: Org and Hyperbole

[Ihor Radchenko]

"Fraga, Eric" <e.fraga@ucl.ac.uk> writes:

> just one quick comment and question (maybe the documentation covers
> this; if so, apologies): when I tried hyperbole years ago, the annoying
> thing was that it took over C-h.  My muscle memory after decades of
> Emacs use was disturbed significantly as I use C-h (for Emacs help) all
> the time.

I posted a bug report related to this in the past and it was fixed. So,
situation may be somewhat better. You might try and see what happens.

However, it appears that something else regarding C-h changed after the
fix as well. At least, I cannot load hyperbole anymore because of some
other aggressive binding (I have C-h rebound to something else):

Debugger entered--Lisp error: (error "Key sequence C-h h starts with non-prefix key C-h")
  (global-set-key [8 104] hyperbole)
  (hkey-initialize)
  (hyperb:init)
  ...
  (require hyperbole nil t)

Best,
Ihor

Re: Org and Hyperbole

[Fraga, Eric]

On Monday,  4 Jul 2022 at 19:01, Ihor Radchenko wrote:
> I posted a bug report related to this in the past and it was fixed. So,
> situation may be somewhat better. You might try and see what happens.

Thank you.  I will play with this system again then.

-- 
Eric S Fraga, @ericsfraga:matrix.org, GnuPG: 0xc89193d8fffcf67d

Re: Org and Hyperbole

[Tim Cross]

"Fraga, Eric" <e.fraga@ucl.ac.uk> writes:

> Robert,
>
> just one quick comment and question (maybe the documentation covers
> this; if so, apologies): when I tried hyperbole years ago, the annoying
> thing was that it took over C-h.  My muscle memory after decades of
> Emacs use was disturbed significantly as I use C-h (for Emacs help) all
> the time.
>

It appears that hyperbole now uses C-h h as its menu key. Other C-h
bindings appear to be unaffected (you just don't get the old Hello file
which you normally have bound to C-h h).

Re: Org and Hyperbole

[Fraga, Eric]

On Monday,  4 Jul 2022 at 21:09, Tim Cross wrote:
> It appears that hyperbole now uses C-h h as its menu key. Other C-h
> bindings appear to be unaffected (you just don't get the old Hello file
> which you normally have bound to C-h h).

Ah, that sounds better.  I can definitely manage without easy access to
the hello file! ;-)

-- 
: Eric S Fraga, with org release_9.5.4-605-g0ed0de in Emacs 29.0.50

Re: Org and Hyperbole

[Robert Weiner]

Correct.  It uses just C-h h to activate the Hyperbole minor mode and to display its keyboard driven minibuffer menu.  This is a normal global key binding which you can easily rebind to anything you like.

-- rsw

> On Jul 4, 2022, at 10:44 AM, Fraga, Eric <e.fraga@ucl.ac.uk> wrote:
> 
> On Monday,  4 Jul 2022 at 21:09, Tim Cross wrote:
>> It appears that hyperbole now uses C-h h as its menu key. Other C-h
>> bindings appear to be unaffected (you just don't get the old Hello file
>> which you normally have bound to C-h h).
> 
> Ah, that sounds better.  I can definitely manage without easy access to
> the hello file! ;-)
> 
> -- 
> : Eric S Fraga, with org release_9.5.4-605-g0ed0de in Emacs 29.0.50

Re: Org and Hyperbole

[Fraga, Eric]

So I installed hyperbole and it works very nicely.  The key binding is
no longer intrusive.  Thank you.
-- 
: Eric S Fraga, with org release_9.5.4-609-g713598 in Emacs 29.0.50

Re: Org and Hyperbole

[Robert Weiner]

[-- Attachment #1: Type: text/plain, Size: 509 bytes --]

Hi Eric:

Wonderful.  We hope more Org users will try Hyperbole as well and let us
know any additional implicit button types  (automatic wiki-like
hyperbuttons) you would like to see in Org mode or other ways Org and
Hyperbole can interoperate.

-- rsw

On Wed, Jul 6, 2022 at 12:58 PM Fraga, Eric <e.fraga@ucl.ac.uk> wrote:

> So I installed hyperbole and it works very nicely.  The key binding is
> no longer intrusive.  Thank you.
> --
> : Eric S Fraga, with org release_9.5.4-609-g713598 in Emacs 29.0.50

[-- Attachment #2: Type: text/html, Size: 1166 bytes --]

Re: Org and Hyperbole

[Fraga, Eric]

Robert,

one immediate issue that has arisen is the binding of C-c C-m (i.e. C-c
RET) to hui-select-thing.  This clobbers the whole gnus-dired-mode-map
in dired mode (for those of us that use gnus...).

Just noting this but should probably take this off-list as it has
nothing to do with org.

-- 
: Eric S Fraga, with org release_9.5.4-609-g713598 in Emacs 29.0.50

Re: Org and Hyperbole

[Robert Weiner]

[-- Attachment #1: Type: text/plain, Size: 789 bytes --]

Hi Eric:

Thanks for pointing this out.  Although, I don't think many people use the
gnus-dired.el library, we'll add this to the todo list.  We have handled
this sort of thing with other keys previously, where the Hyperbole binding
is not utilized if the key has already been bound in the mode prior to
Hyperbole's binding.

-- rsw

On Thu, Jul 7, 2022 at 6:46 AM Fraga, Eric <e.fraga@ucl.ac.uk> wrote:

> Robert,
>
> one immediate issue that has arisen is the binding of C-c C-m (i.e. C-c
> RET) to hui-select-thing.  This clobbers the whole gnus-dired-mode-map
> in dired mode (for those of us that use gnus...).
>
> Just noting this but should probably take this off-list as it has
> nothing to do with org.
>
> --
> : Eric S Fraga, with org release_9.5.4-609-g713598 in Emacs 29.0.50

[-- Attachment #2: Type: text/html, Size: 1481 bytes --]