Org and Hyperbole

Org and Hyperbole

[Juan Manuel Macías]

Hi,

I've been intrigued with GNU Hyperbole for a while. I'm reading the
documentation and trying it out a bit. It seems that its button system
is very powerful. But Org links are also powerful (and exportable), and
can be extended outside of Org docs. It seems that hyperbole offers some
cool stuff that Org also has. And other things that are not in Org. I
find some parts a bit confusing. I wonder if anyone is using hyperbole
with Org and can put here some minimal workflow example where both
complement each other in some way. Just in case I'm missing something
useful...

Best regards,

Juan Manuel 

Re: Org and Hyperbole

[Russell Adams]

On Mon, Jun 20, 2022 at 02:03:15PM +0000, Juan Manuel Macías wrote:
> I've been intrigued with GNU Hyperbole for a while. I'm reading the
> documentation and trying it out a bit. It seems that its button system
> is very powerful. But Org links are also powerful (and exportable), and
> can be extended outside of Org docs. It seems that hyperbole offers some
> cool stuff that Org also has. And other things that are not in Org. I
> find some parts a bit confusing. I wonder if anyone is using hyperbole
> with Org and can put here some minimal workflow example where both
> complement each other in some way. Just in case I'm missing something
> useful...

Juan,

I've often wondered the same thing. I've looked at Hyperbole several
times. They have been great at advertising when a new release
occurs. Yet I find that I can't really find a useful feature in it
that I don't get from Org-mode.

Is there some keen feature I'm missing? What's the use case for
Hyperbole if you're already an Org-mode user?

------------------------------------------------------------------
Russell Adams                            RLAdams@AdamsInfoServ.com
                                    https://www.adamsinfoserv.com/

Re: Org and Hyperbole

[Uwe Brauer]

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

>>> "JMM" == Juan Manuel Macías <maciaschain@posteo.net> writes:

> Hi,
> I've been intrigued with GNU Hyperbole for a while. I'm reading the
> documentation and trying it out a bit. It seems that its button system
> is very powerful. But Org links are also powerful (and exportable), and
> can be extended outside of Org docs. It seems that hyperbole offers some
> cool stuff that Org also has. And other things that are not in Org. I
> find some parts a bit confusing. I wonder if anyone is using hyperbole
> with Org and can put here some minimal workflow example where both
> complement each other in some way. Just in case I'm missing something
> useful...

Quite some time ago (that was at the time org mode was in its infancy) I
gave it a try and found it too confusing and difficult to handle for
every day work. 

There were other package that provided similar (well less) functionality
but were much simpler, however they were not stable that is the links
could be damaged during editing. I don't recall the details.

But I am happy with what org mode offers.

Sorry that may have been not that helpful..

Uwe Brauer 

[-- Attachment #2: smime.p7s --]
[-- Type: application/pkcs7-signature, Size: 5673 bytes --]

Re: Org and Hyperbole

[Bill Burdick]

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

I hadn't heard of it so I'm watching a demo. It looks similar to Oberon
(which heavily influenced Acme and Wily) which is an extremely powerful
"mouse-based text environment".

I'm certainly going to give it a try -- it seems like a great compliment to
org-mode and other Emacs power tools...


-- Bill


On Mon, Jun 20, 2022 at 5:18 PM Juan Manuel Macías <maciaschain@posteo.net>
wrote:

> Hi,
>
> I've been intrigued with GNU Hyperbole for a while. I'm reading the
> documentation and trying it out a bit. It seems that its button system
> is very powerful. But Org links are also powerful (and exportable), and
> can be extended outside of Org docs. It seems that hyperbole offers some
> cool stuff that Org also has. And other things that are not in Org. I
> find some parts a bit confusing. I wonder if anyone is using hyperbole
> with Org and can put here some minimal workflow example where both
> complement each other in some way. Just in case I'm missing something
> useful...
>
> Best regards,
>
> Juan Manuel
>
>

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

Re: Org and Hyperbole

[indieterminacy]

Hi Juan,

On 20-06-2022 16:03, Juan Manuel Macías wrote:
> Hi,
> 
> I've been intrigued with GNU Hyperbole for a while. I'm reading the
> documentation and trying it out a bit. It seems that its button system
> is very powerful. But Org links are also powerful (and exportable), and
> can be extended outside of Org docs. It seems that hyperbole offers 
> some
> cool stuff that Org also has. And other things that are not in Org. I
> find some parts a bit confusing. I wonder if anyone is using hyperbole
> with Org and can put here some minimal workflow example where both
> complement each other in some way. Just in case I'm missing something
> useful...
> 

I recommend Hyperbole, though I must confess Ive been using Orgmode a 
lot less since Ive been focusing on the format GemText.

I should recommend the use of the function defil, for people who like 
regexes and want to operate differing contexts (to launch via the ACTION 
operator). Its mid-grade compared to the more simpler approach and the 
more complex eLisp approach.

While I have not fully applied this technique to my workflow, you can 
see some /stub/ experimentations that are used to provide different 
function calls based upon where the cursor is in the context of a 
specific annotation (namely my annotation approach, Qiuy).

https://git.sr.ht/~indieterminacy/5q50jq_oq_configuring_emacs/tree/master/item/cqc_mqm_interfacing_blooms.el

The logic for the example includes:

<function-call> <function-name> <opening-regex> <closing-regex> 
<cursor-regex> <result-from-context> <options>

As you see below, these things build through to build multiple cursor 
based contexts.
```
(defil qiuy-1q10hqh_1 "^" "q10hqh.*" "1" "{M-: (print \"context_1 1q\") 
RET}" t t)
(defil qiuy-1q10hqh_2 "^1" "10hqh.*" "q" "{M-: (print \"context_2 
[1-6]q\") RET}" t t)
(defil qiuy-1q10hqh_3 "^1q" "0hqh.*" "1" "{M-: (print \"context_3 
1q10\") RET}" t t)
(defil qiuy-1q10hqh_4 "^1q1" "hqh.*" "0" "{M-: (isearch-forward-symbol 
\"q10\") RET}" t t)
(defil qiuy-1q10hqh_5 "^1q10" "qh.*" "h" "{M-: (rg-project \"hqh\" 
\".*\") RET}" t t)
(defil qiuy-1q10hqh_6 "^1q10h" "h.*" "q" "{M-: (print \"context_6 
1q10hqh\") RET}" t t)
(defil qiuy-1q10hqh_7_\s "^1q10hqh" "$" "\s(.*)" "{M-: (print 
\"context_7_\s 1q10hqh \\&\") RET}" t t)
(defil qiuy-1q10hqh_7_\t "^1q10hqh" "$" "\t(.*)" "{M-: (print 
\"context_7_\t 1q10hqh \\&\") RET}" t t)
(defil qiuy-1q10hqh_7_- "^1q10hqh" "$" "-(.*)" "{M-: (print 
\"context_7_- 1q10hqh \\&\") RET}" t t)
(defil qiuy-1q10hqh_7__ "^1q10hqh" "$" "_(.*)" "{M-: (print 
\"context_7__ 1q10hqh \\&\") RET}" t t)
```

Documentation for the function defil can be found here:
https://www.gnu.org/software/hyperbole/man/hyperbole.html#Implicit-Button-Link-Types


The Hyperbole ML is quiet but friendly and informative.

Having examined Hyperbole more broadly, I do wonder if there was more of 
a policy to treat Orgmode as more of a parrallel concern.
Today, there is clearly a proactive effort to align and encourage cross 
usage.
To hear that somebody as accomplished as yourself is dabbling with 
Hyperbole pleases me no end.

It may be worth you visiting one of my knowledge repos here:
https://git.sr.ht/~indieterminacy/3q50cqc_oq_interfaces_emacs

As well as (over time) checking on on these search parameters for my 
username:
https://git.sr.ht/~indieterminacy/?search=hyperbole
https://git.sr.ht/~indieterminacy/?search=koutliner

Of note, I should mention my own project, Icebreaker - which has been 
augmenting the GemText format with terse syntaxes and formats - 
including Hyperboles Koutliner format (which if I understand may be able 
to include orgmode tables in its blocks with the new version - I could 
be wrong here).

Here is a WIP parser written in TXR - for parsing Koutliner blocks (with 
or without my Qiuy annotations) and expressing it as a datalisp:
https://git.sr.ht/~indieterminacy/1q20hqh_oqo_parsing_glean

I shall be tightening it up soon, including integrating it with a WIP 
GemText parser (its terser atm but missing a little):
https://git.sr.ht/~indieterminacy/1q20hqh_kq_parsing_gemtext

An NLNet funded project, I am going to later be exporting some of this 
information into simple Orgmode syntax as a subset of one of the 
deliverables. An earlier protyping is covered here in a more recent 
Fosdem talk:
https://fosdem.org/2022/schedule/event/minimalsyntaxes/

Im happy to answer any more questions with regards to this in this 
thread or elsewhere.

It may be worth highlighting a matrix room my Icebreaker project runs to 
reduce clutter from other MLs.
The members there are friendly, knowledgable and use Orgmode for a range 
of tasks:
https://matrix.to/#/#xq_icebreaker:matrix.org


You are a clear and concise writer and coder. I would love to hear the 
outcomes from this exploration.

If I recall you are an emacspeak user - which I seem to think has been 
praised for its integration with Hyperbole so that should be more than 
enough justification to really get into it.

Kind regards,


-- 
Jonathan McHugh
indieterminacy@libre.brussels

Re: Org and Hyperbole

[Eduardo Ochs]

On Mon, 20 Jun 2022 at 12:28, Russell Adams <RLAdams@adamsinfoserv.com> wrote:
> Juan,
>
> I've often wondered the same thing. I've looked at Hyperbole several
> times. They have been great at advertising when a new release
> occurs. Yet I find that I can't really find a useful feature in it
> that I don't get from Org-mode.
>
> Is there some keen feature I'm missing? What's the use case for
> Hyperbole if you're already an Org-mode user?


Hi Russell,

Some years ago I tried to integrate Hyperbole and eev and 1) I failed
miserably, and 2) I ended up with the impression that Hyperbole is
meant to be "used", not to be "hacked"... for example, in Hyperbole
the action of a button like this,

  {C-h h d a}

is to emulate what happens when the user types `C-h h d a'. This
button works exactly as expected; eev implements something similar,
but in a very simplistic, and slightly buggy, way: when we run this in
eev

  (eek "C-h h d a")

it simply runs this,

  (execute-kbd-macro (read-kbd-macro "C-h h d a"))

that just inserts an "a". The details are here, in the second part,
after the blank lines:

  https://lists.gnu.org/archive/html/hyperbole-users/2020-09/msg00013.html

Hyperbole has some amazing features, but its code needs to be
refactored to make more parts of it easier to use from Lisp... someone
needs to do that, and this someone won't be me, as I'm burnt out. =(
My links about my attempts to learn Hyperbole are here:

  http://angg.twu.net/hyperbole.html

  [[]],
    Eduardo Ochs
    http://angg.twu.net/2021-org-for-non-users.html

Re: Org and Hyperbole

[Juan Manuel Macías]

Hi all,

Thank you very much for your comments and contributions in this thread
about Org & hyperbole, which have helped me a lot to position myself.

Certainly, for the short time I've been using hyperbole, it has me
baffled. It's like someone grabbed all the tools that could be useful
ten minutes before the zombie apocalypse starts. There's all the buttons
stuff, but also a feature to expand regions in a style similar to the
expand-region package, which I use a lot, by the way. And also features
to write emails, store contacts, execute searches, a buffer and frame
control system (this in particular is what most caught my attention
about hiperbole and what I am using the most, since it has some very
useful functionalities). The implicit and explicit buttons system is
certainly powerful, but I don't think it will surprise the average Org
user much in this regard.

I think that Eduardo Ochs's description ("Hyperbole is meant to be used,
not to be hacked") is quite accurate. On the other hand, I find the
hyperbole menu (C-h h) very confusing and ugly. I think it would have
gained in cleanliness if they had used transient.

It seems that the hyperbole developers put a commendable and honest
effort into introducing hyperbole to users. But I perceive that
something is failing in the communication. I suspect that hyperbole is
an attempt to establish synaptic relationships between Emacs documents
and buffers. But that is also what is sought with Org. Without wishing
to make comparisons (because, as I say, my knowledge of hyperbole is
extremely limited) I would say that there is an important difference
between org and hyperbole. Both are huge, and both are complex, and both
are packed with features. But in Org there is a coherent and consistent
language that ties everything together: once you learn how to ask for a
glass of water in the org dialect (something you can do from day one),
it doesn't take long to start more complex conversations. In hiperbole I
don't just see that language that gives consistency to everything, that
"org-style". Or at least it's not so obvious to me. But I'll keep giving
it a chance. The whole window configuration control part is extremely
interesting to me.

Best regards,

Juan Manuel 

Re: Org and Hyperbole

[Tim Cross]

Russell Adams <RLAdams@adamsinfoserv.com> writes:

> On Mon, Jun 20, 2022 at 02:03:15PM +0000, Juan Manuel Macías wrote:
>> I've been intrigued with GNU Hyperbole for a while. I'm reading the
>> documentation and trying it out a bit. It seems that its button system
>> is very powerful. But Org links are also powerful (and exportable), and
>> can be extended outside of Org docs. It seems that hyperbole offers some
>> cool stuff that Org also has. And other things that are not in Org. I
>> find some parts a bit confusing. I wonder if anyone is using hyperbole
>> with Org and can put here some minimal workflow example where both
>> complement each other in some way. Just in case I'm missing something
>> useful...
>
> Juan,
>
> I've often wondered the same thing. I've looked at Hyperbole several
> times. They have been great at advertising when a new release
> occurs. Yet I find that I can't really find a useful feature in it
> that I don't get from Org-mode.
>
> Is there some keen feature I'm missing? What's the use case for
> Hyperbole if you're already an Org-mode user?
>
>                                     https://www.adamsinfoserv.com/

My experiences with it mirror yours. It looked interesting and there
were some ideas which sounded interesting, but when I came to use it, I
found little, if anything, which didn't have a close equivalence in org
mode and many things in org mode which it did not have. 

In the end, it came down to asking myself do I really want yet another
information management framework in my life and the answer was no. I do
vaguely recall (it was a while ago) there were some ideas I thought
would be good to add to org mode though. Unfortunately, I cannot recall
the details now. 

Re: Org and Hyperbole

[David Masterson]

Juan Manuel Macías <maciaschain@posteo.net> writes:

> I've been intrigued with GNU Hyperbole for a while. I'm reading the
> documentation and trying it out a bit. It seems that its button system
> is very powerful. But Org links are also powerful (and exportable), and
> can be extended outside of Org docs. It seems that hyperbole offers some
> cool stuff that Org also has. And other things that are not in Org. I
> find some parts a bit confusing. I wonder if anyone is using hyperbole
> with Org and can put here some minimal workflow example where both
> complement each other in some way. Just in case I'm missing something
> useful...

I haven't touched Hyperbole in ...decades...?  Even then, it was
complicated and full-featured (but I still keep it in my .emacs file).
My discussions with Bob Weiner were interesting at the time and I really
wanted to make use of it.

As you've discovered, it integrates a lot of what Org has in, perhaps, a
tighter fashion (which makes it more complicated, but the pain might be
useful). The Smart Keys and Buttons are very similar to Org.  The
outliner (KOutline) is more powerful than Org, but not integrated with
export capabilities to other formats (I think there is a way of
exporting an outline to Org).  Something that Org does not have is
browsing capabilities for Object Oriented languages.  This is an add-on
(for C++ ?) in Hyperbole (search for OO-Browser).  Since I retired, I
don't do much programming, so Org's project management has been more
interesting to me.

It's nice to see that it's actually still being developed by Bob.

-- 
David Masterson

Re: Org and Hyperbole

[Juan Manuel Macías]

Hi David, 

David Masterson writes:

> I haven't touched Hyperbole in ...decades...?  Even then, it was
> complicated and full-featured (but I still keep it in my .emacs file).
> My discussions with Bob Weiner were interesting at the time and I really
> wanted to make use of it.
>
> As you've discovered, it integrates a lot of what Org has in, perhaps, a
> tighter fashion (which makes it more complicated, but the pain might be
> useful). The Smart Keys and Buttons are very similar to Org.  The
> outliner (KOutline) is more powerful than Org, but not integrated with
> export capabilities to other formats (I think there is a way of
> exporting an outline to Org).  Something that Org does not have is
> browsing capabilities for Object Oriented languages.  This is an add-on
> (for C++ ?) in Hyperbole (search for OO-Browser).  Since I retired, I
> don't do much programming, so Org's project management has been more
> interesting to me.
>
> It's nice to see that it's actually still being developed by Bob.

Thanks for all the interesting facts about hyperbole. I hadn't looked at
the package source code info yet, and didn't know that this is all the
work of one person. I also thought hyperbole was more recent...

It certainly has some interesting stuff. In what way is KOutline more
powerful than Org? Do you think there is any useful feature of KOutline
that could be incorporated into Org?

So far I've been able to find a couple of practical uses for this
package in my workflow. The whole window control system is very
powerful, although it would have been better if it had been a single
separate package, IMHO.

Implicit links have a lot of potential. For example, I've managed to
define some buttons for LaTeX, which recognize LaTeX commands and
environments and lead to the local TeX live documentation or
tex.stackexchange.org. It's like giving a LaTeX document a sort of hover
help. This could also be done in Org, by defining some patterns as
implicit buttons to lead to Org info pages.

Best regards,

Juan Manuel 

Re: Org and Hyperbole

[Bill Burdick]

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

Here's a hyperbole-org integration that lets you use org-mode tables
outside of org-mode files. Shift-middle-click a "recalc" button and it will
recalculate the table right under it (this idea is from an old version of
the Oberon environment I wrote in Java, by the way).

Here's the code:

(defun bill/calc (end)
  (goto-char end)
  (re-search-forward "\n")
  (when (org-at-table-p)
    (org-table-analyze)
    (let* ((table-start (point))
           (rows (1- (length org-table-dlines)))
           (table-end (re-search-forward "\n" nil t rows))
           (inside (<= table-start action-key-depress-prev-point
table-end)))
      (when inside
        (goto-char action-key-depress-prev-point)
        (org-table-maybe-eval-formula))
      (goto-char table-start)
      (call-interactively 'org-table-recalculate)
      (org-table-align))))

(defib recalc ()
  "recalculate a table"
  (save-excursion
    (let* ((pos (point))
           (eol (progn (re-search-forward "\n") (point)))
           (bol (progn (re-search-backward "\n" nil t 2) (1+ (point))))
           (start (progn (goto-char pos) (re-search-backward "<" bol t)))
           (end (progn (goto-char pos) (re-search-forward ">" eol t))))
      ;;(message "pos: %s, prev: %s" (point) action-key-depress-prev-point)
      (and start end (string-match "<recalc[> ].*" (buffer-substring start
end))
           (hact 'bill/calc end)))))

Here's an example table you can put anywhere. Just shift-middle-click on it
to recalculate the org-mode table. Also, if you type a formula (and keep
the cursor on the same line) and then shift-click recalc, it'll handle the
formula:

<recalc>
| a | 12 |
| a |  5 |
#+TBLFM: @1$2=3*4::@2$2=2+3


-- Bill


On Wed, Jun 22, 2022 at 1:38 PM Juan Manuel Macías <maciaschain@posteo.net>
wrote:

> Hi David,
>
> David Masterson writes:
>
> > I haven't touched Hyperbole in ...decades...?  Even then, it was
> > complicated and full-featured (but I still keep it in my .emacs file).
> > My discussions with Bob Weiner were interesting at the time and I really
> > wanted to make use of it.
> >
> > As you've discovered, it integrates a lot of what Org has in, perhaps, a
> > tighter fashion (which makes it more complicated, but the pain might be
> > useful). The Smart Keys and Buttons are very similar to Org.  The
> > outliner (KOutline) is more powerful than Org, but not integrated with
> > export capabilities to other formats (I think there is a way of
> > exporting an outline to Org).  Something that Org does not have is
> > browsing capabilities for Object Oriented languages.  This is an add-on
> > (for C++ ?) in Hyperbole (search for OO-Browser).  Since I retired, I
> > don't do much programming, so Org's project management has been more
> > interesting to me.
> >
> > It's nice to see that it's actually still being developed by Bob.
>
> Thanks for all the interesting facts about hyperbole. I hadn't looked at
> the package source code info yet, and didn't know that this is all the
> work of one person. I also thought hyperbole was more recent...
>
> It certainly has some interesting stuff. In what way is KOutline more
> powerful than Org? Do you think there is any useful feature of KOutline
> that could be incorporated into Org?
>
> So far I've been able to find a couple of practical uses for this
> package in my workflow. The whole window control system is very
> powerful, although it would have been better if it had been a single
> separate package, IMHO.
>
> Implicit links have a lot of potential. For example, I've managed to
> define some buttons for LaTeX, which recognize LaTeX commands and
> environments and lead to the local TeX live documentation or
> tex.stackexchange.org. It's like giving a LaTeX document a sort of hover
> help. This could also be done in Org, by defining some patterns as
> implicit buttons to lead to Org info pages.
>
> Best regards,
>
> Juan Manuel
>
>

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

Re: Org and Hyperbole

[Juan Manuel Macías]

Hi Jonathan, sorry for my late response,

indieterminacy writes:

> I recommend Hyperbole, though I must confess Ive been using Orgmode a 
> lot less since Ive been focusing on the format GemText.
>
> I should recommend the use of the function defil, for people who like 
> regexes and want to operate differing contexts (to launch via the ACTION 
> operator). Its mid-grade compared to the more simpler approach and the 
> more complex eLisp approach.

Thank you very much for all the very interesting information about hyperbole!

I am liking the idea of implicit buttons more and more, and I see a few
applications of this concept that I can find very practical. To play
around with the defil function, which you recommend in your email, I've
tried defining some 'contextual help' for LaTeX and Org. Specifically for
Org it has occurred to me to convert some keywords into implicit buttons
that point to the info pages. Something like this:

#+begin_src emacs-lisp
  (defil org-attr-latex
    "#+" ":" "attr_latex\\|caption"
    (let ((el (org-element-at-point)))
      (cond ((eq (org-element-type el) 'src-block)
	     (lambda (x)
	       (info "(org)Source blocks in LaTeX export")))
	    ((eq (org-element-type el) 'table)
	     (lambda (x)
	       (info "(org)Tables in LaTeX export")))
	    ((eq (org-element-type el) 'plain-list)
	     (lambda (x)
	       (info "(org)Plain lists in LaTeX export")))
	    ((eq (org-element-type el) 'paragraph)
	     (lambda (x)
	       (info "(org)Images in LaTeX export")))
	    ((eq (org-element-type el) 'verse-block)
	     (lambda (x)
	       (info "(org)Verse blocks in LaTeX export")))
	    ((eq (org-element-type el) 'special-block)
	     (lambda (x)
	       (info "(org)Special blocks in LaTeX export")))
	    ((eq (org-element-type el) 'example-block)
	     (lambda (x)
	       (info "(org)Example blocks in LaTeX export")))
	    ((eq (org-element-type el) 'quote-block)
	     (lambda (x)
	       (info "(org)Quote blocks in LaTeX export"))))))

  (defil org-attr-html
    "#+" ":" "attr_html\\|caption"
    (let ((el (org-element-at-point)))
      (cond ((eq (org-element-type el) 'table)
	     (lambda (x)
	       (info "(org)Tables in HTML export")))
	    ((eq (org-element-type el) 'paragraph)
	     (lambda (x)
	       (info "(org)Images in HTML export"))))))


  (defil org-options-kw "#+" ":" "options"
    (lambda (x)
      (info "(org)Export Settings")
      (occur "‘OPTIONS’")))
#+end_src

I've also discovered the defib function, which allows you to define
implicit buttons using predicates, instead of just using regular
expressions and delimiters.

Best regards,

Juan Manuel 

Re: Org and Hyperbole

[Russell Adams]

On Mon, Jun 20, 2022 at 05:26:30PM +0200, Russell Adams wrote:
> Is there some keen feature I'm missing? What's the use case for
> Hyperbole if you're already an Org-mode user?

Watching the replies, I've noticed it all seems to come back to
hyperlinking / hot button support across Emacs modes. Almost sounds
like Apple's Hypercard is evoked in the responses.

I rarely use Org's own links, much less links between documents so
maybe I'm not the target audience.

------------------------------------------------------------------
Russell Adams                            RLAdams@AdamsInfoServ.com
                                    https://www.adamsinfoserv.com/

Re: Org and Hyperbole

[Bill Burdick]

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

Anywhere you use a link or button, you can probably use an emacs command
instead. I think maybe the value of links and buttons is that they're
explicit. It's a reminder in the text and you don't have to learn it.

One thing I noticed in my little "recalc" exercise is that Hyperbole really
really wants the cursor to stay on the button. I used function advice to
make the cursor stay where it was when you clicked the button. This allows
"menubars" to work, lists of buttons that can operate on the text without
warping the cursor to the buttons. This is how Oberon and WIly work and I
think Hyperbole (for my use cases anyway) will benefit from this usage
style.


-- Bill


On Wed, Jun 22, 2022 at 6:15 PM Russell Adams <RLAdams@adamsinfoserv.com>
wrote:

> On Mon, Jun 20, 2022 at 05:26:30PM +0200, Russell Adams wrote:
> > Is there some keen feature I'm missing? What's the use case for
> > Hyperbole if you're already an Org-mode user?
>
> Watching the replies, I've noticed it all seems to come back to
> hyperlinking / hot button support across Emacs modes. Almost sounds
> like Apple's Hypercard is evoked in the responses.
>
> I rarely use Org's own links, much less links between documents so
> maybe I'm not the target audience.
>
> ------------------------------------------------------------------
> Russell Adams                            RLAdams@AdamsInfoServ.com
>                                     https://www.adamsinfoserv.com/
>
>

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

Re: Org and Hyperbole

[David Masterson]

Bill Burdick <bill.burdick@gmail.com> writes:

> Anywhere you use a link or button, you can probably use an emacs
> command instead. I think maybe the value of links and buttons is that
> they're explicit. It's a reminder in the text and you don't have to
> learn it.
>
> One thing I noticed in my little "recalc" exercise is that Hyperbole
> really really wants the cursor to stay on the button. I used function
> advice to make the cursor stay where it was when you clicked the
> button. This allows "menubars" to work, lists of buttons that can
> operate on the text without warping the cursor to the buttons. This is
> how Oberon and WIly work and I think Hyperbole (for my use cases
> anyway) will benefit from this usage style.

Could you provide an example of that function advice?
-- 
David Masterson

Re: Org and Hyperbole

[Bill Burdick]

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

Sure:

(defun bill/restore-calc-point (result)
  (when bill/calc-point
    (goto-char bill/calc-point)
    (setq bill/calc-point nil))
  result)

(advice-add 'hmouse-function :filter-return 'bill/restore-calc-point)

If my recalc function matches, it sets bill/restore-calc-point to a marker
like this:

(setq bill/calc-point (make-marker))

Since it's normally nil, the advice normally just ignores it.


-- Bill


On Wed, Jun 22, 2022 at 9:05 PM David Masterson <dsmasterson@gmail.com>
wrote:

> Bill Burdick <bill.burdick@gmail.com> writes:
>
> > Anywhere you use a link or button, you can probably use an emacs
> > command instead. I think maybe the value of links and buttons is that
> > they're explicit. It's a reminder in the text and you don't have to
> > learn it.
> >
> > One thing I noticed in my little "recalc" exercise is that Hyperbole
> > really really wants the cursor to stay on the button. I used function
> > advice to make the cursor stay where it was when you clicked the
> > button. This allows "menubars" to work, lists of buttons that can
> > operate on the text without warping the cursor to the buttons. This is
> > how Oberon and WIly work and I think Hyperbole (for my use cases
> > anyway) will benefit from this usage style.
>
> Could you provide an example of that function advice?
> --
> David Masterson
>

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

Re: Org and Hyperbole

[David Masterson]

Juan Manuel Macías <maciaschain@posteo.net> writes:

> Hi David, 
>
> David Masterson writes:
>
>> I haven't touched Hyperbole in ...decades...?  Even then, it was
>> complicated and full-featured (but I still keep it in my .emacs file).
>> My discussions with Bob Weiner were interesting at the time and I really
>> wanted to make use of it.
>>
>> As you've discovered, it integrates a lot of what Org has in, perhaps, a
>> tighter fashion (which makes it more complicated, but the pain might be
>> useful). The Smart Keys and Buttons are very similar to Org.  The
>> outliner (KOutline) is more powerful than Org, but not integrated with
>> export capabilities to other formats (I think there is a way of
>> exporting an outline to Org).  Something that Org does not have is
>> browsing capabilities for Object Oriented languages.  This is an add-on
>> (for C++ ?) in Hyperbole (search for OO-Browser).  Since I retired, I
>> don't do much programming, so Org's project management has been more
>> interesting to me.
>>
>> It's nice to see that it's actually still being developed by Bob.
>
> Thanks for all the interesting facts about hyperbole. I hadn't looked at
> the package source code info yet, and didn't know that this is all the
> work of one person. I also thought hyperbole was more recent...
>
> It certainly has some interesting stuff. In what way is KOutline more
> powerful than Org? Do you think there is any useful feature of KOutline
> that could be incorporated into Org?

KOutline has a much larger set of commands for working with outlines.
However, that's an example of complexity in that it's a lot to keep in
your head.  The permanent (hidden) ids make it possible to build (say) a
personal Wiki of information where rearranging the outline doesn't mess
up the links.

> So far I've been able to find a couple of practical uses for this
> package in my workflow. The whole window control system is very
> powerful, although it would have been better if it had been a single
> separate package, IMHO.

I tended to look at EXWM, but didn't get too far. I may look at
Hycontrol again...

> Implicit links have a lot of potential. For example, I've managed to
> define some buttons for LaTeX, which recognize LaTeX commands and
> environments and lead to the local TeX live documentation or
> tex.stackexchange.org. It's like giving a LaTeX document a sort of hover
> help. This could also be done in Org, by defining some patterns as
> implicit buttons to lead to Org info pages.

Have you looked at Hydra?  But Hyperbole's implicit links are better.

-- 
David Masterson

Re: Org and Hyperbole

[David Masterson]

Bill Burdick <bill.burdick@gmail.com> writes:

> Here's a hyperbole-org integration that lets you use org-mode tables
> outside of org-mode files. Shift-middle-click a "recalc" button and it
> will recalculate the table right under it (this idea is from an old
> version of the Oberon environment I wrote in Java, by the way).
>
> Here's the code:
>
> (defun bill/calc (end)
>   (goto-char end)
>   (re-search-forward "\n")
>   (when (org-at-table-p)
>     (org-table-analyze)
>     (let* ((table-start (point))
>            (rows (1- (length org-table-dlines)))
>            (table-end (re-search-forward "\n" nil t rows))
>            (inside (<= table-start action-key-depress-prev-point table-end)))
>       (when inside
>         (goto-char action-key-depress-prev-point)
>         (org-table-maybe-eval-formula))
>       (goto-char table-start)
>       (call-interactively 'org-table-recalculate)
>       (org-table-align))))
>
> (defib recalc ()
>   "recalculate a table"
>   (save-excursion
>     (let* ((pos (point))
>            (eol (progn (re-search-forward "\n") (point)))
>            (bol (progn (re-search-backward "\n" nil t 2) (1+ (point))))
>            (start (progn (goto-char pos) (re-search-backward "<" bol t)))
>            (end (progn (goto-char pos) (re-search-forward ">" eol t))))
>       ;;(message "pos: %s, prev: %s" (point) action-key-depress-prev-point)
>       (and start end (string-match "<recalc[> ].*" (buffer-substring start end))
>            (hact 'bill/calc end)))))
>
> Here's an example table you can put anywhere. Just shift-middle-click
> on it to recalculate the org-mode table. Also, if you type a formula
> (and keep the cursor on the same line) and then shift-click recalc,
> it'll handle the formula:
>
> <recalc>
> | a | 12 |
> | a |  5 |
> #+TBLFM: @1$2=3*4::@2$2=2+3

Isn't this the minor mode orgtbl-mode ?

-- 
David Masterson

Re: Org and Hyperbole

[Bill Burdick]

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

No idea.


-- Bill


On Wed, Jun 22, 2022 at 10:23 PM David Masterson <dsmasterson@gmail.com>
wrote:

> Bill Burdick <bill.burdick@gmail.com> writes:
>
> > Here's a hyperbole-org integration that lets you use org-mode tables
> > outside of org-mode files. Shift-middle-click a "recalc" button and it
> > will recalculate the table right under it (this idea is from an old
> > version of the Oberon environment I wrote in Java, by the way).
> >
> > Here's the code:
> >
> > (defun bill/calc (end)
> >   (goto-char end)
> >   (re-search-forward "\n")
> >   (when (org-at-table-p)
> >     (org-table-analyze)
> >     (let* ((table-start (point))
> >            (rows (1- (length org-table-dlines)))
> >            (table-end (re-search-forward "\n" nil t rows))
> >            (inside (<= table-start action-key-depress-prev-point
> table-end)))
> >       (when inside
> >         (goto-char action-key-depress-prev-point)
> >         (org-table-maybe-eval-formula))
> >       (goto-char table-start)
> >       (call-interactively 'org-table-recalculate)
> >       (org-table-align))))
> >
> > (defib recalc ()
> >   "recalculate a table"
> >   (save-excursion
> >     (let* ((pos (point))
> >            (eol (progn (re-search-forward "\n") (point)))
> >            (bol (progn (re-search-backward "\n" nil t 2) (1+ (point))))
> >            (start (progn (goto-char pos) (re-search-backward "<" bol t)))
> >            (end (progn (goto-char pos) (re-search-forward ">" eol t))))
> >       ;;(message "pos: %s, prev: %s" (point)
> action-key-depress-prev-point)
> >       (and start end (string-match "<recalc[> ].*" (buffer-substring
> start end))
> >            (hact 'bill/calc end)))))
> >
> > Here's an example table you can put anywhere. Just shift-middle-click
> > on it to recalculate the org-mode table. Also, if you type a formula
> > (and keep the cursor on the same line) and then shift-click recalc,
> > it'll handle the formula:
> >
> > <recalc>
> > | a | 12 |
> > | a |  5 |
> > #+TBLFM: @1$2=3*4::@2$2=2+3
>
> Isn't this the minor mode orgtbl-mode ?
>
> --
> David Masterson
>

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

Re: Org and Hyperbole

[Bill Burdick]

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

I just wrote recalc today as a demo so people can extrapolate what they
might do with Hyperbole (calc was handy in my head since I wrote it for
Ober, the Java version of the Oberon environment).

WIth buttons that restore the point to where it was when you clicked, you
can make them operate on the current selection (it looks like Hyperbole
might not save the region though so maybe more function advice is needed
for that). This makes reusable "menu bars" possible:

<recalc> <cut> <copy> <paste>

(changing recalc to find the table at point instead of using the location
of the button).
Highlight a region and shift-middle-click on cut/copy/paste to do that
action on your selection.

This also lets you use button bars in other frames (acting even more like a
real menu bar).

Buttons could also parse contextual information in the button buffer
(and/or the active buffer), something like org-mode properties, that could
influence how the buttons behave. Other buttons could edit this information
to give you document-based behavior. For instance, a button-buffer (like
the menubar) could have behavioral information like this:

<indent>: 4
<justify>: left

Clicking "left" could toggle it between the different types of
justification (left, right, center, full) and clicking on <justify> could
justify the current paragraph. Clicking <indent> could change the
indentation of the current file (if it's a program, it could analyze for
the current indentation and then change it to the desired indentation).

Just thinking out loud here -- this is the sort of thing Ober did and
Hyperbole looks like a framework that makes it not too hard to do that for
Emacs.


-- Bill


On Wed, Jun 22, 2022 at 10:26 PM Bill Burdick <bill.burdick@gmail.com>
wrote:

> No idea.
>
>
> -- Bill
>
>
> On Wed, Jun 22, 2022 at 10:23 PM David Masterson <dsmasterson@gmail.com>
> wrote:
>
>> Bill Burdick <bill.burdick@gmail.com> writes:
>>
>> > Here's a hyperbole-org integration that lets you use org-mode tables
>> > outside of org-mode files. Shift-middle-click a "recalc" button and it
>> > will recalculate the table right under it (this idea is from an old
>> > version of the Oberon environment I wrote in Java, by the way).
>> >
>> > Here's the code:
>> >
>> > (defun bill/calc (end)
>> >   (goto-char end)
>> >   (re-search-forward "\n")
>> >   (when (org-at-table-p)
>> >     (org-table-analyze)
>> >     (let* ((table-start (point))
>> >            (rows (1- (length org-table-dlines)))
>> >            (table-end (re-search-forward "\n" nil t rows))
>> >            (inside (<= table-start action-key-depress-prev-point
>> table-end)))
>> >       (when inside
>> >         (goto-char action-key-depress-prev-point)
>> >         (org-table-maybe-eval-formula))
>> >       (goto-char table-start)
>> >       (call-interactively 'org-table-recalculate)
>> >       (org-table-align))))
>> >
>> > (defib recalc ()
>> >   "recalculate a table"
>> >   (save-excursion
>> >     (let* ((pos (point))
>> >            (eol (progn (re-search-forward "\n") (point)))
>> >            (bol (progn (re-search-backward "\n" nil t 2) (1+ (point))))
>> >            (start (progn (goto-char pos) (re-search-backward "<" bol
>> t)))
>> >            (end (progn (goto-char pos) (re-search-forward ">" eol t))))
>> >       ;;(message "pos: %s, prev: %s" (point)
>> action-key-depress-prev-point)
>> >       (and start end (string-match "<recalc[> ].*" (buffer-substring
>> start end))
>> >            (hact 'bill/calc end)))))
>> >
>> > Here's an example table you can put anywhere. Just shift-middle-click
>> > on it to recalculate the org-mode table. Also, if you type a formula
>> > (and keep the cursor on the same line) and then shift-click recalc,
>> > it'll handle the formula:
>> >
>> > <recalc>
>> > | a | 12 |
>> > | a |  5 |
>> > #+TBLFM: @1$2=3*4::@2$2=2+3
>>
>> Isn't this the minor mode orgtbl-mode ?
>>
>> --
>> David Masterson
>>
>

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

Re: Org and Hyperbole

[linux_hpc_akr]

I use both Org and Hyperbole.

I'm a sysadmin so I do a lot with files and paths and URLs.  A lot of which
happens not in org files.

Being able to treat the files/paths/URLs as implicit buttons anywhere is
pretty valuable to me.

I just hit hkey-either on a filename/path and emacs opens it.  Or I hit
hkey-either on a URL and emacs sends to my web browser.  And I can do this in
any file or terminal or anywhere that I find myself in emacs.  I don't have to
think about it.  It just works.

Just my $0.02 in favor of using both Org and Hyperbole.

-- 
- Bill
+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
Bill Benedetto     <bbenedetto@goodyear.com>    The Goodyear Tire & Rubber Co.
I don't speak for Goodyear and they don't speak for me.  We're both happy.

Re: Org and Hyperbole

[Samuel Wales]

i am interested in whether hyperbole can inspire org.  or maybe spin
off stuff that is useful for org.

i find org-link-minor-mode to be reeeeeeeeeeeeeally useful.  limited,
but useful.  does tses too.

i use it in non-org files to link to other places in the same file, mostly.

also i insert the reverse link.  but i also use org id links to link
to org.  which, bidir is manual.  also external links.

idk about hyperbole, but i really like the idea of emacs being able to
link all types of files and maybe even file-less buffers all around.
bidirectionally.   also annotate, with and without modifying the
annotated file, with org as backend.

i like nonbreakable links.  org-id is great, might be useful in such a
pan-emacs setup via links similar to extensible syntax id marker links
so that it is nonbreakable and bidirectional and controllable, all
without manual maintenance.

those would also allow graph-theoretical stuff but i don't think i
need that.  except bidirectional links and lists of links, perhaps
traversable via emacs's standard next-error mechanism or something
similar.

i noticed something a bit peculiar recently.  i did org-store-link in
a non-org file and a properties drawer was created at top [maint].
idk if hte org-id system will remembver that indefinitely or not; file
moves might be an issue.

-- 
The Kafka Pandemic

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

Re: Org and Hyperbole

[David Masterson]

Bill Burdick <bill.burdick@gmail.com> writes:

> Sure:
>
> (defun bill/restore-calc-point (result)
>   (when bill/calc-point
>     (goto-char bill/calc-point)
>     (setq bill/calc-point nil))
>   result)
>
> (advice-add 'hmouse-function :filter-return 'bill/restore-calc-point)
>
> If my recalc function matches, it sets bill/restore-calc-point to a marker like this:
>
> (setq bill/calc-point (make-marker))
>
> Since it's normally nil, the advice normally just ignores it.

Thanks.  I wanted to learn more about advising functions.

-- 
David Masterson

Re: Org and Hyperbole

[David Masterson]

Samuel Wales <samologist@gmail.com> writes:

> i am interested in whether hyperbole can inspire org.  or maybe spin
> off stuff that is useful for org.

Hyperbole is loaded and activated in your .emacs file.  Therefore, it's
features are available in any file you work on (including Org
files). Many of the features may be useful to you as a replacement to a
feature in Org or something to work along side Org.  Dig into the
Hyperbole manual...


-- 
David Masterson

Re: Org and Hyperbole

[indieterminacy]

On 23-06-2022 06:04, David Masterson wrote:
> Samuel Wales <samologist@gmail.com> writes:
> 
>> i am interested in whether hyperbole can inspire org.  or maybe spin
>> off stuff that is useful for org.
> 
> Hyperbole is loaded and activated in your .emacs file.  Therefore, it's
> features are available in any file you work on (including Org
> files). Many of the features may be useful to you as a replacement to a
> feature in Org or something to work along side Org.  Dig into the
> Hyperbole manual...

any buffer!

so it works inside emacs teminal emulators too!
-- 
Jonathan McHugh
indieterminacy@libre.brussels

Re: Org and Hyperbole

[Bill Burdick]

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

In case anyone's interested in writing hyperbole commands that can act on
regions but be located in other windows...

To write a hyperbole command that restores the previous window and
selection, just call bill/hyp-load-state at the start of your code and call
bill/hyp-restore at the end (see bill/recalc for an example).

This lets <recalc> recalculate org tables in any buffer with the button in
a different (or the same) window.

Here's some example text:

<recalc>

Here's a table. Click in it and then shift-middle-click recalc, above.
"aaa12" should change to "12" and your cursor should stay in the same place.
| a | aaa12 |
| a |  5 |
|   | 17 |
#+TBLFM: @1$2=3*4::@2$2=2+3::@3$2=vsum(@1..@2)

Here's my current definition for recalc

(defvar bill/hyp-state nil)

(defun bill/hyp-save-state (&rest args)
  (setq bill/hyp-state
        (list (selected-window) (point-marker) (and (use-region-p)
(copy-marker (mark-marker))))))

(cl-defun bill/hyp-load-state (&optional (state bill/hyp-state))
  (let ((window (car state))
        (point (cadr state))
        (mark (caddr state)))
    (when window
      (select-window window)
      (set-buffer (marker-buffer point))
      (and mark (set-mark (marker-position mark)))
      (goto-char point))))

(defun bill/hyp-restore ()
  (let ((state bill/hyp-state))
    (run-at-time 0 nil (lambda () (bill/hyp-load-state state)))))

(advice-add 'action-key-depress :before 'bill/hyp-save-state)
;; evaluate this to remove the advice
;;(advice-remove 'action-key-depress 'bill/hyp-save-state)

(defun bill/recalc (end)
  (let ((act-point action-key-depress-prev-point))
    (bill/hyp-load-state)
    (when (org-at-table-p)
      (org-table-analyze)
      (org-table-maybe-eval-formula)
      (call-interactively 'org-table-recalculate)
      (org-table-align)))
  (bill/hyp-restore))

(defib recalc ()
  "recalculate the table at point"
  (save-excursion
    (let* ((pos (point))
           (eol (progn (re-search-forward "\n") (point)))
           (bol (progn (re-search-backward "\n" nil t 2) (1+ (point))))
           (start (progn (goto-char pos) (re-search-backward "<" bol t)))
           (end (progn (goto-char pos) (re-search-forward ">" eol t))))
      (and start end (string-match "<recalc[> ].*" (buffer-substring start
end))
           (hact 'bill/recalc end)))))


-- Bill

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

Re: Org and Hyperbole

[Bill Burdick]

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

Note that recalc relies on lexical binding so if you use it, whatever file
it's in needs

;; -*- lexical-binding: t -*-

at the top.


-- Bill

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

Re: Org and Hyperbole

[Samuel Banya]

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

I'll be honest, every time I've ever seen Hyperbole attempted to be explained, it goes over my head in 2 seconds.

It seems like something akin to Acme where its mouse driven button events that trigger other things to occur.

Could never find a single solid video that dumbed down Hyperbole to make it useful for the average person though unfortunately. Seems neat though.

Sincerely,

Sam

On Thu, Jun 23, 2022, at 1:22 AM, indieterminacy wrote:
> On 23-06-2022 06:04, David Masterson wrote:
> > Samuel Wales <samologist@gmail.com> writes:
> > 
> >> i am interested in whether hyperbole can inspire org.  or maybe spin
> >> off stuff that is useful for org.
> > 
> > Hyperbole is loaded and activated in your .emacs file.  Therefore, it's
> > features are available in any file you work on (including Org
> > files). Many of the features may be useful to you as a replacement to a
> > feature in Org or something to work along side Org.  Dig into the
> > Hyperbole manual...
> 
> any buffer!
> 
> so it works inside emacs teminal emulators too!
> -- 
> Jonathan McHugh
> indieterminacy@libre.brussels
> 
> 

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

Re: Org and Hyperbole

[Eduardo Ochs]

On Wed, 22 Jun 2022 at 11:36, Bill Burdick <bill.burdick@gmail.com> wrote:
>
> Here's a hyperbole-org integration that lets you use org-mode tables outside of org-mode files. Shift-middle-click a "recalc" button and it will recalculate the table right under it (this idea is from an old version of the Oberon environment I wrote in Java, by the way).
>
> Here's the code:
>
> (defun bill/calc (end)
>   (goto-char end)
>   (re-search-forward "\n")
>   (when (org-at-table-p)
>     (org-table-analyze)
>     (let* ((table-start (point))
>            (rows (1- (length org-table-dlines)))
>            (table-end (re-search-forward "\n" nil t rows))
>            (inside (<= table-start action-key-depress-prev-point table-end)))
>       (when inside
>         (goto-char action-key-depress-prev-point)
>         (org-table-maybe-eval-formula))
>       (goto-char table-start)
>       (call-interactively 'org-table-recalculate)
>       (org-table-align))))
>
> (defib recalc ()
>   "recalculate a table"
>   (save-excursion
>     (let* ((pos (point))
>            (eol (progn (re-search-forward "\n") (point)))
>            (bol (progn (re-search-backward "\n" nil t 2) (1+ (point))))
>            (start (progn (goto-char pos) (re-search-backward "<" bol t)))
>            (end (progn (goto-char pos) (re-search-forward ">" eol t))))
>       ;;(message "pos: %s, prev: %s" (point) action-key-depress-prev-point)
>       (and start end (string-match "<recalc[> ].*" (buffer-substring start end))
>            (hact 'bill/calc end)))))
>
> Here's an example table you can put anywhere. Just shift-middle-click on it to recalculate the org-mode table. Also, if you type a formula (and keep the cursor on the same line) and then shift-click recalc, it'll handle the formula:
>
> <recalc>
> | a | 12 |
> | a |  5 |
> #+TBLFM: @1$2=3*4::@2$2=2+3


Hi Bill,

can I ask you for help on something that looks easy but that I'm not
being able to do (due to temporary braindeadness)?

How do we reimplement your <recalc> button as a sexp that can be run
with C-e C-x C-e? In eev all "buttons" are simply sexps that can
executed by variants of eval-last-sexp - as explained here:

  http://angg.twu.net/eev-intros/find-eev-quick-intro.html#3

I'm trying to translate your <recalc> to "eev style", but I'm
failing...

  Thanks in advance!
    Eduardo Ochs
    http://angg.twu.net/#eev

Re: Org and Hyperbole

[Samuel Wales]

i was indeed aware that one can dig into hyperbole's manual and load
it and keep using it for lots of buffers alongside org.  i first
learned about hyperbole in the 1990s or so and it seemed rather neat
and it seems intriguing still.

but that is not the model i was talking about in my post.  [there is
of course nothing wrong with that model.]

On 6/22/22, indieterminacy <indieterminacy@libre.brussels> wrote:
> On 23-06-2022 06:04, David Masterson wrote:
>> Samuel Wales <samologist@gmail.com> writes:
>>
>>> i am interested in whether hyperbole can inspire org.  or maybe spin
>>> off stuff that is useful for org.
>>
>> Hyperbole is loaded and activated in your .emacs file.  Therefore, it's
>> features are available in any file you work on (including Org
>> files). Many of the features may be useful to you as a replacement to a
>> feature in Org or something to work along side Org.  Dig into the
>> Hyperbole manual...
>
> any buffer!
>
> so it works inside emacs teminal emulators too!
> --
> Jonathan McHugh
> indieterminacy@libre.brussels
>


-- 
The Kafka Pandemic

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

Re: Org and Hyperbole

[Samuel Wales]

[p.s.  it also was not the topic i was talking about in my post.  :]
i was talking about specific features of links.]

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

[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: 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

[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

[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]

On 24-06-2022 01:36, Samuel Wales wrote:
> [p.s.  it also was not the topic i was talking about in my post.  :]
> i was talking about specific features of links.]

I use (general) links functionality that hyperbole provides inside my 
emacs shell.

Apologies for not matching your specificity.

-- 
Jonathan McHugh
indieterminacy@libre.brussels

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

[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: 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

[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

[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

[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: 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

[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

[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

[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]

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]

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

[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: 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: 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

[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

[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

[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

[Jean Louis]

* Tim Cross <theophilusx@gmail.com> [2022-06-21 02:43]:
> 
> Russell Adams <RLAdams@adamsinfoserv.com> writes:
> 
> > On Mon, Jun 20, 2022 at 02:03:15PM +0000, Juan Manuel Macías wrote:
> >> I've been intrigued with GNU Hyperbole for a while. I'm reading the
> >> documentation and trying it out a bit. It seems that its button system
> >> is very powerful. But Org links are also powerful (and exportable), and
> >> can be extended outside of Org docs. It seems that hyperbole offers some
> >> cool stuff that Org also has. And other things that are not in Org. I
> >> find some parts a bit confusing. I wonder if anyone is using hyperbole
> >> with Org and can put here some minimal workflow example where both
> >> complement each other in some way. Just in case I'm missing something
> >> useful...
> >
> > Juan,
> >
> > I've often wondered the same thing. I've looked at Hyperbole several
> > times. They have been great at advertising when a new release
> > occurs. Yet I find that I can't really find a useful feature in it
> > that I don't get from Org-mode.
> >
> > Is there some keen feature I'm missing? What's the use case for
> > Hyperbole if you're already an Org-mode user?
> >
> >                                     https://www.adamsinfoserv.com/
> 
> My experiences with it mirror yours. It looked interesting and there
> were some ideas which sounded interesting, but when I came to use it, I
> found little, if anything, which didn't have a close equivalence in org
> mode and many things in org mode which it did not have. 
> 
> In the end, it came down to asking myself do I really want yet another
> information management framework in my life and the answer was no. I do
> vaguely recall (it was a while ago) there were some ideas I thought
> would be good to add to org mode though. Unfortunately, I cannot recall
> the details now. 

I somehow cannot relate to it, Hyperbole and Org mode are quite
different things. I have Hyperbole all the time here running, no
matter if I use Org mode or what other lightweight markup language.

Let's say there is region marked, I use sometimes Hyperbole to search
Internet for marked term. That is not related and not comparable to
Org mode which is meant to handle markup in a text file.

Hyperbole is what it says, extravagant exaggeration. It is meta to
Org.

I have specific window setup with different buffers and I want to
remember it, then I use Hyperbole {C-h h w n a} to remember it.

One can understand it by running demo {C-h h d d}, it is not related
to Org mode, it is to be used in Emacs over anything, regardless of modes.


-- 
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]

* Tim Cross <theophilusx@gmail.com> [2022-06-21 02:43]:
> In the end, it came down to asking myself do I really want yet another
> information management framework in my life and the answer was no. I do
> vaguely recall (it was a while ago) there were some ideas I thought
> would be good to add to org mode though. Unfortunately, I cannot recall
> the details now.

Some peope do not need any information managemenet. That is fine.

Doug Engelbart envisioned something back in time which we still do not
have completed for mankind.

Doug Engelbart Institute - Boosting mankind's capability for coping with complex, urgent problems:
https://www.dougengelbart.org/

Org mode is one way to the information management. Hyperbole is other
way. They are going in parallel, they are not replacing each other.

On personal computer I use personal people management, but on remote
computer I would use HyRolo to quickly insert contacts. I would then
later import them to my personal database.

I can't use Org for information management. I have 240034 people and
groups in the database, and their 197815 addresses, and 273836 of
their phone numbers and email addresses, with related 46365
Hyperdocuments or elementary objects consisting of everything like:

Acknowledgment, Action, Agreement, Appointment, Article, Attachment,
Audio, Backlink, Book, Borrowed Item, Break-up, Business Plan,
Business Profile, CBR, CSV, Call, Case, Certificate, City, Clipboard
(Primary), Cognition, Common Lisp, Contact Information, Contract,
Corporate Resolution, DB-ID, DISEASE, DJVU, DOCX, DONE, Debt, Default,
Demand, Dev-T, Directory Action ➜, Directory, Document, Dream, Drug
Information, E-mail For Mailing List, E-mail Signature, E-mail
Snippet, EPUB, Emacs Lisp Hyperlink, Emacs Lisp, Enriched, Ethics
Report, Event, Expenses Report, FOLLOW-UP, File, Financial Subject,
Flyer, Follow-up, Food, GnuCash, Gnumeric, Good News, HTML
Hyperdocument, Header Image for Letterhead, Health Remedy, HyperScope
ID, ID Document, Image, Info Node, Inquiry, Instruction, Instructions,
Invoice, Kotl (Hyperbole Outline), Launch Program, Letter, Letterhead,
Link to Map, Loan Request, Local File, Location, Maff, Magic, Markdown
(Pandoc, espresso), Markdown, Mbox, Media, Meeting, Message-ID, Mobi,
Mount Point, Music, Note, ODS, ODT, Offer, Online Account,
Opportunity, Org Heading, Org Standalone, Org, PDF Query, PDF by Page
Nr., PDF, Page in physical book, Paraset, Partnership Offer, Password,
Patent, Pay, Payslip, Phone, Place, Poem, PostgreSQL, Power of
Attorney, Practical Skill, Press Release, Pricing, Profile Picture,
Progress, Project, Proposal, Public Bidding, QUOTATION, Question,
Questionnaire, Quotation, Quote, Recipe, Reference, Report, Request
For Proposal, Request for quotation, SMS, SUCCESS, SVG, Schedule of
Fees, Scheme, Service, Set ➾, Shell Command, Shell Script, Signature,
Song, Spreadsheet, Task, Template, Text with images, Text, Track,
Training, Travel, URL for Image, Video (exact time), Video, Voice, WRS
Area, WRS Page Annotation, WRS Page, WRS Unprocessed Page, WWW,
Warning, XCF, Xournalpp, YouTube Video (exact time), YouTube, aMule,
reStructuredText, txt2tags.

While Org is meant to be all knowing information management, I keep it
pretty silent for basic lightweight markup and as unit of information
within much larger Dynamic Knowledge Repository as envisioned by
Engelbart.

-- 
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]

* indieterminacy <indieterminacy@libre.brussels> [2022-06-20 19:26]:
> I recommend Hyperbole, though I must confess Ive been using Orgmode a lot
> less since Ive been focusing on the format GemText.

Hyperbole and Orgmode are programs of different types, and thus not
comparable to each other. Sure I can compare the traffic signs to cars
on the road, but those objects are not of the same type.

GemText is nice simple format. It needs exporters and convertors. I
would not like writing exclusively for Gemtext. Maybe you may ask
Pandoc maintainer to provide conversion to GemText, and txt2tags
maintainers to provide conversion variations.

> As well as (over time) checking on on these search parameters for my
> username:
> https://git.sr.ht/~indieterminacy/?search=hyperbole
> https://git.sr.ht/~indieterminacy/?search=koutliner

By simple clicking I cannot see relevant notes.

-- 
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]

Your ideas are inspirational.

Myself I think of implementing meta links that shall look similar like
this: ⟦ (link 123) ⟧ and which would be inserted very easily by
completing the choice among many links.

The link would appear underlined anywhere in Emacs if mode is turned
on. It would appear either with its own name, if the link 123 has name
"ABC" it would appear as "ABC" otherwise it could appear as user
wishes ⟦ (link 123 "This is link") ⟧.

Main feature of such link would be to convert itself into whatever
lightweight markup mode is related to major mode of the file.

If we speak of markdown hyperlink, it would become markdown, if we
speak of Org mode hyperlink, it becomes Org mode style, or Asciidoctor
style, txt2tags, reStructuredText or HTML style.

* Samuel Wales <samologist@gmail.com> [2022-06-23 04:13]:
> i am interested in whether hyperbole can inspire org.  or maybe spin
> off stuff that is useful for org.
> 
> i find org-link-minor-mode to be reeeeeeeeeeeeeally useful.  limited,
> but useful.  does tses too.
> 
> i use it in non-org files to link to other places in the same file, mostly.
> 
> also i insert the reverse link.  but i also use org id links to link
> to org.  which, bidir is manual.  also external links.
> 
> idk about hyperbole, but i really like the idea of emacs being able to
> link all types of files and maybe even file-less buffers all around.
> bidirectionally.   also annotate, with and without modifying the
> annotated file, with org as backend.
> 
> i like nonbreakable links.  org-id is great, might be useful in such a
> pan-emacs setup via links similar to extensible syntax id marker links
> so that it is nonbreakable and bidirectional and controllable, all
> without manual maintenance.
> 
> those would also allow graph-theoretical stuff but i don't think i
> need that.  except bidirectional links and lists of links, perhaps
> traversable via emacs's standard next-error mechanism or something
> similar.
> 
> i noticed something a bit peculiar recently.  i did org-store-link in
> a non-org file and a properties drawer was created at top [maint].
> idk if hte org-id system will remembver that indefinitely or not; file
> moves might be an issue.

-- 
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

[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

[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

[Russell Adams]

On Tue, Sep 27, 2022 at 04:06:17PM +0300, Jean Louis wrote:
> * Tim Cross <theophilusx@gmail.com> [2022-06-21 02:43]:
> >
> > Russell Adams <RLAdams@adamsinfoserv.com> writes:
> >
> > > On Mon, Jun 20, 2022 at 02:03:15PM +0000, Juan Manuel Macías wrote:
> > >> I've been intrigued with GNU Hyperbole for a while. I'm reading the
> > >> documentation and trying it out a bit. It seems that its button system
> > >> is very powerful. But Org links are also powerful (and exportable), and
> > >> can be extended outside of Org docs. It seems that hyperbole offers some
> > >> cool stuff that Org also has. And other things that are not in Org. I
> > >> find some parts a bit confusing. I wonder if anyone is using hyperbole
> > >> with Org and can put here some minimal workflow example where both
> > >> complement each other in some way. Just in case I'm missing something
> > >> useful...
> > >
> > > Juan,
> > >
> > > I've often wondered the same thing. I've looked at Hyperbole several
> > > times. They have been great at advertising when a new release
> > > occurs. Yet I find that I can't really find a useful feature in it
> > > that I don't get from Org-mode.
> > >
> > > Is there some keen feature I'm missing? What's the use case for
> > > Hyperbole if you're already an Org-mode user?
> > >
> > >                                     https://www.adamsinfoserv.com/
> >
> > My experiences with it mirror yours. It looked interesting and there
> > were some ideas which sounded interesting, but when I came to use it, I
> > found little, if anything, which didn't have a close equivalence in org
> > mode and many things in org mode which it did not have.
> >
> > In the end, it came down to asking myself do I really want yet another
> > information management framework in my life and the answer was no. I do
> > vaguely recall (it was a while ago) there were some ideas I thought
> > would be good to add to org mode though. Unfortunately, I cannot recall
> > the details now.
>
> I somehow cannot relate to it, Hyperbole and Org mode are quite
> different things. I have Hyperbole all the time here running, no
> matter if I use Org mode or what other lightweight markup language.


Could you point to some usage of Hyperbole that could help address
it's use case?

------------------------------------------------------------------
Russell Adams                            RLAdams@AdamsInfoServ.com
                                    https://www.adamsinfoserv.com/

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

[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

[Payas Relekar]

Robert Weiner <rsw@gnu.org> writes:

> 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.

Not Jean, but as someone using Org with Hyperbole, this is a great news!

> 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.

For my 2c:

- Multiple small files vs single large file.
  I currently have former, with org-roam taking care of finding, linking
  and backlinking between files, making it a non-issue to easily build a
  network of connected topics/thoughts

- Daily notes
  Every day gets its own note, only generated if visited. This allows
  dumping the thoughts at that moment rather than first hunting the
  correct node. Then they can be easily filtered into actual topic note,
  or just be referenced via backlinks buffer

- sqlite might just be better, considering overhead of opening and
  parsing hundreds-thousands of small files is non-negligible.

- Refiling
  Refile/move the subtree (in Org terms) can be easily moved to another
  file and the links automatically point to new location. This means I
  can always know rearranging stuff later is a possibility, and its less
  cognitive burden to organize.

In short, the framework takes care of organization and makes retrieval
easy and all I have to worry about is the content.

Thanks,
Payas

--

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

[Jean Louis]

* Samuel Wales <samologist@gmail.com> [2022-06-23 04:13]:

> i am interested in whether hyperbole can inspire org.  or maybe spin
> off stuff that is useful for org.

Hyperbole is used on top of anything, useful for any mode, be it read
only, writable, any.

> i find org-link-minor-mode to be reeeeeeeeeeeeeally useful.  limited,
> but useful.  does tses too.

If it would work like it promises, fine, it doesn't. I can't know why.

What is "tses"?

> also i insert the reverse link.  but i also use org id links to link
> to org.  which, bidir is manual.  also external links.

Please show how does it look the reverse link?

Show me the bidir?

Show me external links for better undertanding.

> i like nonbreakable links.

How such link looks like?

> those would also allow graph-theoretical stuff but i don't think i
> need that.  except bidirectional links and lists of links, perhaps
> traversable via emacs's standard next-error mechanism or something
> similar.

Show me how bidirectional links work?

--
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]

* 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: 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]

* Payas Relekar <relekarpayas@gmail.com> [2022-10-04 09:56]:
> Not Jean, but as someone using Org with Hyperbole, this is a great news!
> 
> > 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.
> 
> For my 2c:
> 
> - Multiple small files vs single large file.
>   I currently have former, with org-roam taking care of finding, linking
>   and backlinking between files, making it a non-issue to easily build a
>   network of connected topics/thoughts

Org-roam is yet another attempt to make relational database out of Org
text by using exlusive ID links. I can't know, I am just assuming that
it has to parse plethora of Org files and links inside to understand
what is linking to what. Old fashioned way wish to ignore the
existence of RDBMs.

Files have its location and user is supposed to move file in file
system, to think about it and decide where it is. I don't think it is
right so in 21st century. It is better to know very descriptive name
of file, but as user to forget where is file located.

On the ATM machine I want cash out and not to know where is cash
located. I just want to access it, and be able to access it from many
locations.

Only RDBMs are for that purpose.

> - Daily notes
>   Every day gets its own note, only generated if visited. This allows
>   dumping the thoughts at that moment rather than first hunting the
>   correct node. Then they can be easily filtered into actual topic note,
>   or just be referenced via backlinks buffer

That is very nice. That is how I sort screenshots and videos as well,
by date when they are made. 

If note is related to person, then system is to recognize it
automatically. Notes are related mostly to people: groups or lists of
people such as "Emacs Users" or "Org Users" or "ABC SLIME LTD" and
individual people, and people assigned to various tasks, and groups
assigned to tasks, and people supposed to get reports of it.

> - sqlite might just be better, considering overhead of opening and
>   parsing hundreds-thousands of small files is non-negligible.

Of course it is so much better option than keeping stuff in text. All
properties shall be in the database. SQLite is not a network database,
thus it disables collaboration. It is better developing with
PostgresSQL or MariaDB, or other network databases.

> - Refiling
>   Refile/move the subtree (in Org terms) can be easily moved to another
>   file and the links automatically point to new location. This means I
>   can always know rearranging stuff later is a possibility, and its less
>   cognitive burden to organize.

Once my files are stored in the meta system, I have no idea where they
are located. File name does not matter any more. Many files arrive
with strange file names. If file gets its meta name then its storage
and file name in file system may remain static forever, while separate
meta data can be changed. Meta data may tell that "ABC FILE" shall be
moved to "CAR REPAIR" while file name on file system does not move
ever. Moving files in file system is tedious. It requires operations
such as listing of directories, opening file manager, copying,
renaming, etc. Instead it is better to go straight to the thought. Do
you wnat file "ABC FILE" to be moved in the collection or header of
"CAR REPAIR?" Then choose "CAR REPAIR" by completion and let it go
there. File in the file system may remain immutable, only the meta
data of its position may change.

-- 
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]

* 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

[Hendursaga]

Jean Louis <bugs@gnu.support> writes:

> Of course it is so much better option than keeping stuff in text. All properties shall be in the database. SQLite is not a network database, thus it disables collaboration. It is better developing with PostgresSQL or MariaDB, or other network databases.

Vanilla SQLite, that is. There are multiple[1] SQLite[2] addons[3] around[4] that add some sort of distributed layer to it, most being zero-cost (or at least low-cost) abstractions. Pretty cool, I'd say!

~ Hendursaga

[1] https://dqlite.io/
[2] https://litestream.io/
[3] https://github.com/losfair/mvsqlite
[4] https://github.com/rqlite/rqlite

Re: Org and Hyperbole

[Jean Louis]

* Hendursaga <hendursaga@aol.com> [2022-10-08 03:46]:
> Jean Louis <bugs@gnu.support> writes:
> 
> > Of course it is so much better option than keeping stuff in text. All properties shall be in the database. SQLite is not a network database, thus it disables collaboration. It is better developing with PostgresSQL or MariaDB, or other network databases.
> 
> Vanilla SQLite, that is. There are multiple[1] SQLite[2] addons[3] around[4] that add some sort of distributed layer to it, most being zero-cost (or at least low-cost) abstractions. Pretty cool, I'd say!
> 
> ~ Hendursaga
> 
> [1] https://dqlite.io/
> [2] https://litestream.io/
> [3] https://github.com/losfair/mvsqlite
> [4] https://github.com/rqlite/rqlite

Thanks, insightful, I have reviewed links. But none tells me that it
is truly network based database. Of course one may replicate files
through network and send data, that is not what is meant with network
database. One can make layers on top of it, but that does not make it
multi user or suitable for collaboration.

From:
https://www.sqlite.org/whentouse.html

,----
| Many concurrent writers? → choose client/server
| 
| If many threads and/or processes need to write the database at the
| same instant (and they cannot queue up and take turns) then it is best
| to select a database engine that supports that capability, which
| always means a client/server database engine.
| 
| SQLite only supports one writer at a time per database file. But in
| most cases, a write transaction only takes milliseconds and so
| multiple writers can simply take turns. SQLite will handle more write
| concurrency than many people suspect. Nevertheless, client/server
| database systems, because they have a long-running server process at
| hand to coordinate access, can usually handle far more write
| concurrency than SQLite ever will. 
`----


-- 
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: 4298 bytes --]

Hi Guys:

I know what SQLite, org-roam and multi-user RDBMSes are and I use all of
these things at various levels.  They are useful in many ways as you have
pointed out and across time, we may consider optional integrations but one
of the core design principles of Hyperbole is to work in all fairly current
major versions of Emacs (today this is back to V27) on any display device
and to not require any other external packages or C-compiled modules.  Now
we will add optional package support where useful as we have done for
Treemacs, ace-window and org-rifle but never require such things to use all
of Hyperbole's base functionality.  We then know that all Emacs users can
install Hyperbole and use it effectively without any external dependencies
required, whether on a terminal or an old operating system or what have
you.  This is part of the value of Emacs, common capabilities across a wide
spectrum of computing environments.

If I had my druthers, Hyperbole would ship pre-compiled as well since in
the past the byte-compiled code was forward-compatible across many major
Emacs versions, but this no longer seems to be the case to me and the Emacs
package system requires byte-compilation at installation time anyway, so we
have a bit less of a 'turn-key' system than desired.

Although we build Hyperbole so it can be highly customized and programmed,
we know that many people are just looking for ready to use productivity
improving packages, many more than want to hack on a package.  Therefore,
we focus our energies on delivering more and more value in that direction.

Org-roam is very capable for many people and we are not out to simply
replicate it and slightly improve upon its behavior.  We want to provide a
simpler, more contained solution for people who like and use HyRolo and
want a similar solution for note taking.  Quick and easy-to-use where you
can get in and out quickly, restoring your prior context rapidly, working
with multiple file formats and usable wherever you use Emacs.

-- rsw

On Sat, Oct 8, 2022 at 1:03 AM Jean Louis <bugs@gnu.support> wrote:

> * Hendursaga <hendursaga@aol.com> [2022-10-08 03:46]:
> > Jean Louis <bugs@gnu.support> writes:
> >
> > > Of course it is so much better option than keeping stuff in text. All
> properties shall be in the database. SQLite is not a network database, thus
> it disables collaboration. It is better developing with PostgresSQL or
> MariaDB, or other network databases.
> >
> > Vanilla SQLite, that is. There are multiple[1] SQLite[2] addons[3]
> around[4] that add some sort of distributed layer to it, most being
> zero-cost (or at least low-cost) abstractions. Pretty cool, I'd say!
> >
> > ~ Hendursaga
> >
> > [1] https://dqlite.io/
> > [2] https://litestream.io/
> > [3] https://github.com/losfair/mvsqlite
> > [4] https://github.com/rqlite/rqlite
>
> Thanks, insightful, I have reviewed links. But none tells me that it
> is truly network based database. Of course one may replicate files
> through network and send data, that is not what is meant with network
> database. One can make layers on top of it, but that does not make it
> multi user or suitable for collaboration.
>
> From:
> https://www.sqlite.org/whentouse.html
>
> ,----
> | Many concurrent writers? → choose client/server
> |
> | If many threads and/or processes need to write the database at the
> | same instant (and they cannot queue up and take turns) then it is best
> | to select a database engine that supports that capability, which
> | always means a client/server database engine.
> |
> | SQLite only supports one writer at a time per database file. But in
> | most cases, a write transaction only takes milliseconds and so
> | multiple writers can simply take turns. SQLite will handle more write
> | concurrency than many people suspect. Nevertheless, client/server
> | database systems, because they have a long-running server process at
> | hand to coordinate access, can usually handle far more write
> | concurrency than SQLite ever will.
> `----
>
>
> --
> 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: 6099 bytes --]

Re: Org and Hyperbole

[Robert Weiner]

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

On Tue, Sep 27, 2022 at 11:50 AM Russell Adams <RLAdams@adamsinfoserv.com>
wrote:

>
> Could you point to some usage of Hyperbole that could help address
> it's use case?
>

Hi Russell:

There are videos.  The 'Overview and Demo' video has section links in the
description so you can jump to just sections that interest you:

  https://www.gnu.org/software/hyperbole/#videos

There is a Why Use Hyperbole document with various use cases:

  https://www.gnu.org/software/hyperbole/HY-WHY.html

There are user quotes that explain why they can't live without Hyperbole:

  https://www.gnu.org/software/hyperbole/#user-quotes

There is a Reddit page where I list a bunch of the things I do with
Hyperbole frequently, many with the single Action Key, M-RETURN:


https://www.reddit.com/r/emacs/comments/jk3cn0/daily_ways_gnu_hyperbole_helps_me_stay_in_flow/

And there is both a FAST-DEMO and older more extensive DEMO included with
Hyperbole, meant to be read and interacted with when you have Hyperbole
available (not just read as a web page as shown here):

  https://www.gnu.org/software/hyperbole/FAST-DEMO.html

  https://www.gnu.org/software/hyperbole/DEMO.html

And now Hyperbole works really well with Org mode so you can enjoy both
together to multiply your productivity.

-- rsw

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

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

[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

[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 --]

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

[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

[Robert Weiner]

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

On Tue, Oct 4, 2022 at 3:06 AM Payas Relekar <relekarpayas@gmail.com> wrote:

> Robert Weiner <rsw@gnu.org> writes:
>
> > 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.
>
> Not Jean, but as someone using Org with Hyperbole, this is a great news!
>

Good to hear.  Maybe you can provide early feedback when it hits the
Hyperbole pre-release in the elpa-devel package archive (pre-releases of
Hyperbole packaged up from the git master branch tip).

>
> > 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.
>
> For my 2c:
>
> - Multiple small files vs single large file.
>   I currently have former, with org-roam taking care of finding, linking
>   and backlinking between files, making it a non-issue to easily build a
>   network of connected topics/thoughts
>

Yes.  It will search over many files and even recursive directories of
files.  Org-roam has a good model for rapid searching, so we'll have to
consider something similar.  It might not be in the first release but will
come by the second major release.

>
> - Daily notes
>   Every day gets its own note, only generated if visited. This allows
>   dumping the thoughts at that moment rather than first hunting the
>   correct node. Then they can be easily filtered into actual topic note,
>   or just be referenced via backlinks buffer
>

Each note will have an optional datetime stamp which will be on by
default.  If you care to make one note per day, you can do that.

>
> - sqlite might just be better, considering overhead of opening and
>   parsing hundreds-thousands of small files is non-negligible.
>

Yes, that is the reason for desiring some kind of database-backed indexing.

>
> - Refiling
>   Refile/move the subtree (in Org terms) can be easily moved to another
>   file and the links automatically point to new location. This means I
>   can always know rearranging stuff later is a possibility, and its less
>   cognitive burden to organize.
>

Yes.  The idea is that you initially capture notes into a single default
file and then can quickly refile them as needed.

>
> In short, the framework takes care of organization and makes retrieval
> easy and all I have to worry about is the content.
>

Yes, I think we typically do this throughout Hyperbole, as it is very
important to us.

Thanks for the thoughts.

-- rsw

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

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

[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

[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

[Payas Relekar]

Robert Weiner <rsw@gnu.org> writes:

> Good to hear.  Maybe you can provide early feedback when it hits the
> Hyperbole pre-release in the elpa-devel package archive (pre-releases of
> Hyperbole packaged up from the git master branch tip).

I'll be happy to! Unfortunately I'm not able to always follow this list,
so if possible, please let me know when you have something I can try
out.

> Yes.  It will search over many files and even recursive directories of
> files.  Org-roam has a good model for rapid searching, so we'll have to
> consider something similar.  It might not be in the first release but will
> come by the second major release.

Thanks! I've found that without instant/near-instant search the chain of
thought breaks easily (Thanks, ADHD!), so this one is quite important.

> Each note will have an optional datetime stamp which will be on by
> default.  If you care to make one note per day, you can do that.

Sounds good!

> Yes, that is the reason for desiring some kind of database-backed indexing.

Yes, but from your other email it appears this one is not going to
happen due to previous Emacs versions not having built-in sqlite. Have
you thought of any alternate way for achieving same performance without
any built-in database?

> Yes.  The idea is that you initially capture notes into a single default
> file and then can quickly refile them as needed.

While single default file sounds good, individual daily files are better
IME. Because the single file inevitably becomes too large, unwieldy and
generally not the best place to go through quickly.

>> In short, the framework takes care of organization and makes retrieval
>> easy and all I have to worry about is the content.
>>
>
> Yes, I think we typically do this throughout Hyperbole, as it is very
> important to us.

Thanks! Hyperbole has been really good experience so far, because of
practically zero config and batteries included approach. Better
integration with stock Emacs stuff like Org, Gnus and Dired is always
welcome.

Thanks a lot for working on Hyperbole and being responsive!

--

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

[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

[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

[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

[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

[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]

* 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

[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

[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: 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