|
Warning: this is an htmlized version!
The original is here, and the conversion rules are here. |
#######
#
# E-scripts on Hyperbole.
#
# Note 1: use the eev command (defined in eev.el) and the
# ee alias (in my .zshrc) to execute parts of this file.
# Executing this file as a whole makes no sense.
# An introduction to eev can be found here:
#
# (find-eev-quick-intro)
# http://angg.twu.net/eev-intros/find-eev-quick-intro.html
#
# Note 2: be VERY careful and make sure you understand what
# you're doing.
#
# Note 3: If you use a shell other than zsh things like |&
# and the for loops may not work.
#
# Note 4: I always run as root.
#
# Note 5: some parts are too old and don't work anymore. Some
# never worked.
#
# Note 6: the definitions for the find-xxxfile commands are on my
# .emacs.
#
# Note 7: if you see a strange command check my .zshrc -- it may
# be defined there as a function or an alias.
#
# Note 8: the sections without dates are always older than the
# sections with dates.
#
# This file is at <http://angg.twu.net/e/hyperbole.e>
# or at <http://angg.twu.net/e/hyperbole.e.html>.
# See also <http://angg.twu.net/emacs.html>,
# <http://angg.twu.net/.emacs[.html]>,
# <http://angg.twu.net/.zshrc[.html]>,
# <http://angg.twu.net/escripts.html>,
# and <http://angg.twu.net/>.
#
#######
# «.mailing-lists» (to "mailing-lists")
# «.hyperbole» (to "hyperbole")
# «.hyperbole-eev-mail-1» (to "hyperbole-eev-mail-1")
# «.hyperbole-eev-mail-2» (to "hyperbole-eev-mail-2")
# «.turn-off» (to "turn-off")
# «.hyperbole-mailing-lists» (to "hyperbole-mailing-lists")
# «.hyperbole-videos» (to "hyperbole-videos")
# «.hyperscope» (to "hyperscope")
# «.email-2020sep20» (to "email-2020sep20")
# «.my-email-2020sep21» (to "my-email-2020sep21")
# «.koutline» (to "koutline")
# «.bring-your-text-to-life» (to "bring-your-text-to-life")
# «.hyp-and-eev-2020sep27» (to "hyp-and-eev-2020sep27")
# «.hyp-and-eev-2020sep30» (to "hyp-and-eev-2020sep30")
# «.rocket-buttons» (to "rocket-buttons")
# «.o-h-and-e-524» (to "o-h-and-e-524")
# «.hyp-and-org-2022jun20» (to "hyp-and-org-2022jun20")
# «.hyp-disable-2022jun23» (to "hyp-disable-2022jun23")
# «.on-and-off» (to "on-and-off")
# «.M-RET-on-action-button» (to "M-RET-on-action-button")
# «.o-h-and-e-738» (to "o-h-and-e-738")
# «.o-h-and-e-742» (to "o-h-and-e-742")
# «.o-h-and-e-750» (to "o-h-and-e-750")
# «.o-h-and-e-757» (to "o-h-and-e-757")
# «.o-h-and-e-801» (to "o-h-and-e-801")
# «.o-h-and-e-802» (to "o-h-and-e-802")
# «.hypobole» (to "hypobole")
See:
http://angg.twu.net/hyperbole.html
#####
#
# mailing-list
# 2021may21
#
#####
# «mailing-lists» (to ".mailing-lists")
# https://savannah.gnu.org/mail/?group=hyperbole
# http://lists.gnu.org/archive/html/hyperbole-users/
# https://lists.gnu.org/mailman/listinfo/hyperbole-users
# http://lists.gnu.org/archive/html/bug-hyperbole/
# http://lists.gnu.org/mailman/listinfo/bug-hyperbole
#####
#
# Hyperbole
# 2000jan08 / 2019apr20
#
#####
# «hyperbole» (to ".hyperbole")
# https://www.gnu.org/software/hyperbole/
# (find-epackages "\n hyperbole " t)
# (find-epackage 'hyperbole)
# (find-elpafile "hyperbole-7.0.2/")
# (code-c-d "hyperbole" "~/.emacs.d/elpa/hyperbole-7.0.2/" "hyperbole")
# (find-hyperbolefile "")
# (find-hyperbolefile "DEMO")
# (find-hyperbolenode "")
# (find-hyperbolenode "Buttons")
# (find-hyperbolenode "Installation")
# (find-hyperbolenode "Installation" "(package-refresh-contents)")
# (require 'hyperbole)
# (eek "M-h M-k C-h h ;; hyperbole")
# (find-hyperbolenode "Manual Overview")
https://www.reddit.com/r/emacs/comments/by28x5/my_gnu_hyperbole_vision_quest_or_jupiter_and/
# (code-c-d "hyperbole" "~/.emacs.d/elpa/hyperbole-7.0.2/" "hyperbole")
# (find-hyperbolefile "")
# (find-hyperbolefile "DEMO")
# (find-hyperbolenode "")
# (find-hyperbolenode "Buttons")
# (find-hyperbolenode "Installation")
# (find-hyperbolenode "Installation" "(package-refresh-contents)")
(find-ekeymapdescr hui:menu-mode-map)
(find-ekeymapdescr hyrolo-mode-map)
# Old:
#
rm -Rv /usr/src/hyperbole/
cd /usr/src/
tar -xvzf $S/ftp/ftp.beopen.com/pub/hyperbole/beopen-hyperbole-4.18.tgz
cd /usr/src/hyperbole/
#
# (code-c-d "hypb" "/usr/src/hyperbole/")
# (find-hypbfile "")
# (find-hypbfile "HY-README" "To autoload Hyperbole")
(defvar hyperb:dir "/usr/src/hyperbole/")
(load (expand-file-name "hversion" hyperb:dir))
(load (expand-file-name "hyperbole" hyperb:dir))
(require 'hsite)
# Not ok yet
#####
#
# Bridge between Hyperbole and eev: e-mail 1
# 2019apr20
#
#####
# «hyperbole-eev-mail-1» (to ".hyperbole-eev-mail-1")
# https://github.com/edrx/eev/issues/1
# https://github.com/edrx/eev/issues/1#issuecomment-485137009
Hi Robert,
the design principles of eev and Hyperbole are too different! I think
that the "right way" right now is to build a bridge between eev and
Hyperbole, with a mini-tutorial of Hyperbole for eev users (I'm
working on a version 0.0 of that right now, with "eev users" being
"me"), and something correspondent in the other direction...
Can I send some questions? They will have some eev-isms in them, but
note that you can run all their hyperlinks in them with `C-e C-x C-e'
if you have done this:
(require 'eev-load)
You don't even need the eev-mode keybindings.
I installed Hyperbole from ELPA and these are some of my first
relevant elisp hyperlinks:
(find-epackage 'hyperbole)
(require 'hyperbole)
(code-c-d "elpa" "~/.emacs.d/elpa/")
(code-c-d "hyperbole" "~/.emacs.d/elpa/hyperbole-7.0.2/" "hyperbole")
(find-elpafile "hyperbole-readme.txt")
(find-elpafile "" ""hyperbole)
(find-hyperbolefile "DEMO")
(find-hyperbolefile "DEMO" "Action Key is {M-RET}")
(find-hyperbolefile "DEMO" "Assist Key is {C-u M-RET}")
(find-hyperbolefile "DEMO" "Press the Action Key within this <(button)>")
(find-hyperbolenode "")
(find-hyperbolenode "Installation")
(find-hyperbolenode "Buttons")
(eek "M-h M-k M-RET ;; hkey-either")
(find-efunctiondescr 'hkey-either)
(find-efunction 'hkey-either)
(find-efunction 'action-key)
(find-efunction 'assist-key)
Here are my first questions...
1. How does hyperbole know that when I open this file
(find-fline "~/.emacs.d/elpa/hyperbole-7.0.2/DEMO")
(find-hyperbolefile "DEMO")
it has to fontify the strings like "<(button)>"? The file seems to be
in fundamental mode to me...
2. Can you give me a sexp that will perform the same action as M-RET
does when I type it on "<(button)>"? And on "<(keyboard macros)>"? And
on "<(glossary)>"?
Thanks in advance!!!
Eduardo Ochs
http://angg.twu.net/#eev
#####
#
# Bridge between Hyperbole and eev: e-mail 2
# 2019apr21
#
#####
# «hyperbole-eev-mail-2» (to ".hyperbole-eev-mail-2")
# https://github.com/edrx/eev/issues/1#issuecomment-485276834
Nope, action-key on these hbuttons
<(button)>
<(Smart Mouse Keys)>
<(toggle-scroll-proportional)>
is not the same as running these sexps
(button)
(Smart Mouse Keys)
(toggle-scroll-proportional)
in the file DEMO... and when I copied the <(...)>s to another file and
try to type M-RET on them I get this "hypb:error":
(Hyperbole Action Key): No action defined for this context; try another location.
Hyperbole does look interesting, but I am getting the impression that
our design principles are not only different, they are OPPOSITE! Let
me copy here a paragraph that I sent to Stefan Monnier in a discussion
a few weeks ago... I'll uppercase some parts for emphasis, and add
some [...]s.
"I've met many people over the years who have been Forth
enthusiasts in the past, and we often end up discussing what made
Forth so thrilling to use at that time - and what we can do to
adapt its ideas to the computers of today. My personal impression
is that Forth's main points were not the ones that I listed at
the beginning of this section, and that I said that were easy to
quantify; rather, what was most important was that NOTHING WAS
HIDDEN, there were NO COMPLEX DATA STRUCTURES around with
"don't-look-at-this" parts (think on garbage collection in Lua,
for example, and Lua's tables - [in Lua] BEGINNERS NEED TO BE
CONVINCED TO SEE THESE THINGS ABSTRACTLY, as the concrete details
of the implementation are hard), and everything [in Forth] -
code, data, dictionaries, stacks - were just linear sequences of
bytes, that could be read and modified directly if we wished to.
We had TOTAL FREEDOM, defining new words was quick, and
experiments were quick to make; that gave us a sense of power
that was totally different from, say, the one that a Python user
feels today because he has huge libraries at his fingertips."
(From: http://angg.twu.net/miniforth-article.html)
My experience with eev is that people have very short attention spans.
I have at most two minutes to show each of the basic principles -
1) "Lisp can be run from anywhere in Emacs",
2) "use <f8> on red-star lines to open a terminal running an
interpreter and make it the target buffer, and <f8> on
non-red-star lines to send these lines to the target",
and I've tried to prepare material to use these 2 minutes, or 2+2
minutes at most, the best that I can...
I've spent 6 HOURS on Hyperbole in the last days - about 2 of those
writing these e-mails - and I still haven't found neither:
1) the code that fontifies the "<(...)>"s - though this message
http://lists.gnu.org/archive/html/hyperbole-users/2016-07/msg00004.html
MAY have a hint,
2) the function that processes the body of a "<(...)>" - I mean, I
was able to find these, but I didn't go very far from there...
(eek "M-h M-k M-RET ;; hkey-either")
(find-efunctiondescr 'hkey-either)
(find-efunction 'hkey-either)
(find-efunction 'action-key)
(find-efunction 'assist-key)
3) the list of regexps that should be at the core of this idea from
<https://www.gnu.org/software/hyperbole/>:
"Buttons and Smart Keys: A set of hyperbutton types which supply
core hypertext and other behaviors. Buttons may be added to
documents (explicit buttons) with a simple drag between windows,
no markup language needed. Implicit buttons are patterns of
regular text that Hyperbole recognizes and then uses to perform
specified actions, e.g. bug#24568 displays the bug status
information for that bug number."
This is incredibly frustrating. You are probably not going to answer
anything useful, and my attention window for learning Hyperbole will
close. =( =( =(
Cheers,
Eduardo Ochs
http://angg.twu.net/#eev
P.S.: did you take a look at these section of the eev tutorials? In
the third one I've included a link to a video - just watch it between
"t=16s" and "t=30s".
(find-eev-quick-intro "2. Evaluating Lisp")
http://angg.twu.net/eev-intros/find-eev-quick-intro.html#2
(find-eev-quick-intro "3. Elisp hyperlinks")
http://angg.twu.net/eev-intros/find-eev-quick-intro.html#3
(find-eev-quick-intro "6.1. The main key: <F8>")
http://angg.twu.net/eev-intros/find-eev-quick-intro.html#6.1
https://www.youtube.com/watch?v=Lj_zKC5BR64&t=16s
(find-eval-intro "7. Pos-spec-lists")
http://angg.twu.net/eev-intros/find-eval-intro.html#7
#####
#
# turn-off
# 2022may27
#
#####
# «turn-off» (to ".turn-off")
# How to turn hyperbole off:
# http://lists.gnu.org/archive/html/hyperbole-users/2016-07/msg00004.html
#####
#
# Hyperbole mailing lists
# 2019apr21
#
#####
# «hyperbole-mailing-lists» (to ".hyperbole-mailing-lists")
# https://lists.gnu.org/archive/html/hyperbole-users/2019-04/msg00000.html Hyperbole for eev users
Hi list,
I am the author of eev - see:
http://angg.twu.net/#eev
http://angg.twu.net/eev-intros/find-eev-quick-intro.html
and I am trying to build a "bridge" between eev and Hyperbole...
If one loads eev with
(package-install 'eev)
(require 'eev-load)
then each of the sexps below can be used as an elisp hyperlink... if
eev-mode is active then they can be executed with just `M-e', but
people who prefer to work with the eev-mode keymap turned off can
execute them with `C-e C-x C-e' (obs: to run the main tutorial of eev,
do this: `M-x eev-beginner')... but I'm digressing. The non-obvious sexps
below are all elisp hyperlinks:
(find-epackage 'hyperbole)
(require 'hyperbole)
(code-c-d "elpa" "~/.emacs.d/elpa/")
(code-c-d "hyperbole" "~/.emacs.d/elpa/hyperbole-8.0.0/" "hyperbole")
(find-elpafile "hyperbole-readme.txt")
(find-elpafile "" "hyperbole")
(find-hyperbolefile "DEMO")
(find-hyperbolefile "DEMO" "Action Key is {M-RET}")
(find-hyperbolefile "DEMO" "Assist Key is {C-u M-RET}")
(find-hyperbolefile "DEMO" "Press the Action Key within this <(button)>")
(find-hyperbolenode "")
(find-hyperbolenode "Installation")
(find-hyperbolenode "Buttons")
(eek "M-h M-k M-RET ;; hkey-either")
(find-efunctiondescr 'hkey-either)
(find-efunction 'hkey-either)
(find-efunction 'action-key)
(find-efunction 'assist-key)
This one opens the file "DEMO" in the Hyperbole directory and jumps to
the first occurrence of the string "Press the Action Key within this
<(button)>" in it:
(find-hyperbolefile "DEMO" "Press the Action Key within this <(button)>")
I am trying to understand what happens under the hood when I place the
point on the string "<(button)>" and type the action key... the elisp
hyperlinks below show some interesting things,
(find-hyperbolefile "DEMO" "(bu")
(find-hyperbolefile "DEMO" "(bu" '(eek "M-RET"))
(find-hyperbolefile "DEMO" "(bu" '(eek "<<action-key>>"))
(find-hyperbolefile "DEMO" "(bu" '(eek "C-h A"))
(find-hyperbolefile "DEMO" "(bu" '(eek "<<hkey-help>>"))
but I'm a bit stuck after this (caveat: I'm a newbie with less than 6
hours playing with Hyperbole!)...
Let me try to formulate some precise questions.
1. This section of "HY-ABOUT" mentions "patterns":
(find-hyperbolefile "HY-ABOUT" "1. Buttons and Smart Keys")
(find-hyperbolefile "HY-ABOUT" "1. Buttons and Smart Keys" "patterns")
My guess is that there is a list of pairs of regexps/actions
somewhere, and that there is a (low-level) way to inspect that
list, and to find the pattern that matches the current button and
its associated action. How do I do that?
2. What is the hook (?) that fontifies the things like "<(button)>"?
My guess it that it's `hproperty:but-create'. Is that right? I
found that with:
(find-hyperbolegrep "grep --color -nH -e hook *.el")
(find-hyperbolegrep "grep --color -nH -e find-file-hook *.el")
(find-efunctiondescr 'hproperty:but-create)
(find-efunction 'hproperty:but-create)
Thanks in advance!!!
Eduardo Ochs
http://angg.twu.net/#eev
P.S.: This discussion started at:
https://github.com/edrx/eev/issues/1
#####
#
# hyperbole-videos
# 2019jun26
#
#####
# «hyperbole-videos» (to ".hyperbole-videos")
# https://www.reddit.com/r/emacs/comments/by28x5/my_gnu_hyperbole_vision_quest_or_jupiter_and/
# https://www.youtube.com/channel/UCNRwswKKpjOlOVfFTS73P9A
# https://www.youtube.com/watch?v=8lMlJed0-OM
# https://www.youtube.com/watch?v=M3-aMh1ccJk&t=470s
# (find-youtubedl-links "/sda5/videos/" "GNU_Hyperbole_-_Find_Web_Search" "8lMlJed0-OM" ".mp4" "hypsearch")
# (find-video "/sda5/videos/GNU_Hyperbole_-_Find_Web_Search-8lMlJed0-OM.mp4")
# (find-youtubedl-links "/sda5/videos/" "GNU_Hyperbole_-_HyControl_the_fast_frame_and_window_manager_for_GNU_Emacs" "M3-aMh1ccJk" ".mp4" "hyphyc")
# (code-video "hyphycvideo" "/sda5/videos/GNU_Hyperbole_-_HyControl_the_fast_frame_and_window_manager_for_GNU_Emacs-M3-aMh1ccJk.mp4")
# (find-hyphycvideo)
# (find-hyphycvideo "0:00")
# (find-hyphycvideo "17:12" "Toggle smart key debugging")
# (find-hyphycvideo "19:30" "Override local keys")
#####
#
# hyperscope
# 2019aug26
#
#####
# «hyperscope» (to ".hyperscope")
http://dougengelbart.org/content/view/154/86/
http://dougengelbart.org/content/view/216/000/#HyperScope
#####
#
# email-2020sep20
# 2020sep20
#
#####
# «email-2020sep20» (to ".email-2020sep20")
# https://lists.gnu.org/archive/html/hyperbole-users/2020-09/msg00001.html
# (find-epackage 'hyperbole)
# (code-c-d "hyperbole" "~/.emacs.d/elpa/hyperbole-7.1.2/" "hyperbole")
# (find-hyperbolefile "")
# (find-efunctiondescr 'hyperbole)
# (find-hyperbolefile "DEMO")
# (find-hyperbolefile "DEMO" "* Smart Keys")
# (find-hyperbolefile "DEMO" "Press the Action Key within this")
# (find-hyperbolenode "Installation")
# (find-hyperbolenode "Installation" "(require 'hyperbole)")
# (find-hyperbolefile "hyperbole.el" "(defun hkey-initialize ")
# (find-hyperbolenode "Explicit Buttons")
# (find-hyperbolenode "Explicit Buttons" ".hypb")
# (find-hyperbolenode "Explicit Buttons" ".hypb" "within the same directory")
# (find-hyperbolefile "hbdata.el" "hattr:filename")
# (find-hyperbolefile "hbdata.el" "hattr:filename" ".hypb")
# Re: Emacs NYC Video Release: Bring Your Text to Life the Easy Way with G
Hi Jean:
From the start, Hyperbole was designed as a toolkit to allow people to
manage unstructured and semi-structured textual information, namely
personaliz day-to-day information, that doesn't fit neatly in
databases. Most of this information and the way people want to
structure it is highly personal, so the custom button types and the
information underlying the buttons would not typically be shared
publicly. People wouldn't normally share their contact lists, emails
or even personal writings nor the buttons within.
What is public of course are the button and action types included with
Hyperbole and associated demos/tutorials as you see in the DEMO file
{C-h h d d} and potential applications listed in the Why Use Hyperbole
writeup, {C-h h d w}.
If the examples provided in the DEMO are insufficient for you to
create your own Hyperbole-verse, please let us know what is missing.
Basincally, you just create your global personal button file, HYPB,
with {C-h h b p}, place explicit and named implicit buttons in here
that you want to reference frequently, organizing it as an Emacs
outline if you like, and then all of these buttons become global
buttons automatically that you can reference from anywhere with {C-h h
g a}. As you get more advanced, you embed buttons in other files
including your hyrolo, {C-h h r a} and Koutlines, {C-h h k c}, both of
which are documented in the Hyperbole manual.
The Hyperbole manual presently lacks a section describing how to build
your own buttons types as this is pretty simple for anyone who can
program in Elisp because definitions are almost just like regular
defuns (just look at "hibtypes.el" and "hactypes.el"). But as time
allows, we plan to add this section.
Hyperbole is an easy-to-use toolkit you mold to your needs, like
simple Python scripts or functions for comparison. Although it has
some pre-built uses, just as programming languages don't come with
extensive applications as examples, neither does Hyperbole. If you
would like to see one specific application, have a look at
"hib-doc.el" in the Hyperbole distribution which shows how to
implement a simple document-index that can display multi-media
documents based on document ids.
I think you'll find that most current uses are the simplest ones:
activating implicit buttons in existing documents or shell output
text, using HyRolo for contact management, structuring documents with
Koutlines and looking up programming definitions or cross-references
with the Action Key.
Cheers,
Bob
#####
#
# My e-mail to the Hyperbole mailing list in 2020sep21
# 2020sep21
#
#####
# «my-email-2020sep21» (to ".my-email-2020sep21")
# https://lists.gnu.org/archive/html/hyperbole-users/2020-09/msg00006.html
# (defun e () (interactive) (find-es "hyperbole" "my-email-2020sep21"))
# (defun u () (interactive) (eup "hyperbole" "my-email-2020sep21"))
Hi Robert,
I gave Hyperbole another try but I did not get very far... I think I'm
in the category "If the examples provided in the DEMO are insufficient
for you to create your own Hyperbole-verse, please let us know what is
missing", so here are some questions - with lots of eev links to what
I discovered; for help on the eev functions that I used visit the URL
below and click on the function names.
http://angg.twu.net/e/hyperbole.e.html#my-email-2020sep21
So: I installed hyperbole with `M-x list-packages' and then ran this
sexp to define some functions to access the Hyperbole directory and
the info file:
(code-c-d "hyperbole" "~/.emacs.d/elpa/hyperbole-7.1.2/" "hyperbole")
for example:
(find-hyperbolefile "DEMO")
(find-hyperbolefile "DEMO" "\n* Smart Keys")
(find-hyperbolefile "DEMO" "Press the Action Key within this")
(find-hyperbolenode "Installation")
(find-hyperbolenode "Installation" "(require 'hyperbole)")
According to "Installation" I can activate hyperbole for the current
Emacs session by running this by hand:
(require 'hyperbole)
If I do that and I visit "DEMO" again,
(find-hyperbolefile "DEMO" "Press the Action Key within this")
then the strings "<(button)>" and "<(Smart Mouse Keys)>" will be
highlighted. Running `M-x describe-text-properties' on them says:
There is an overlay here:
From 20344 to 20364
face hbut
They are not "buttons" in the sense of:
(find-node "(elisp)Buttons")
in particular, they don't have a special keymap. I search for M-RET,
and it turns out that it was installed in the _global_ keymap. I
looked for the other basic keys of Hyperbole,
(find-elongkey-links "M-RET ;; hkey-either")
(find-elongkey-links "C-h h ;; hyperbole")
(find-elongkey-links "C-h A ;; hkey-help")
and I found that they are defined here:
(find-hyperbolefile "hmouse-drv.el" "(defun hkey-either ")
(find-hyperbolefile "hui-mini.el" "(defun hyperbole ")
(find-hyperbolefile "hmouse-drv.el" "(defun hkey-help ")
and installed in the global keymap by:
(find-hyperbolefile "hyperbole.el" "(defun hkey-initialize ")
I looked for a way to turn Hyperbole mode off, and I couldn't find it.
It seems that `M-x hyperbole-toggle-bindings' can sort of do that,
(find-hyperbolefile "hyperbole.el" "(defun hyperbole-toggle-bindings ")
(find-hyperbolenode "Smart Key Bindings" "hyperbole-toggle-bindings")
but I don't know how to turn off the thing that highlights strings
like "<(button)>" and "<(Smart Mouse Keys)>". They are highlighted
even in files where they are don't work... by a hook, I guess? if I
type M-RET on them in the file in which I am writing this e-mail I get
this error:
(Hyperbole Action Key): No action defined for this context; try another location
That's because they are "explicit buttons", it seems (?), and the
directory in which I am editing this e-mail doesn't have a ".hypb"
file. I was able to find more info about how these buttons work in
these links,
(find-hyperbolenode "Explicit Buttons")
(find-hyperbolenode "Explicit Buttons" ".hypb")
(find-hyperbolenode "Explicit Buttons" ".hypb" "within the same directory")
(find-hyperbolefile "hbdata.el" "hattr:filename")
(find-hyperbolefile "hbdata.el" "hattr:filename" ".hypb")
(find-hyperbolefile ".hypb")
(find-hyperbolefile ".hypb" "DEMO")
(find-hyperbolefile ".hypb" "DEMO" "button")
(find-hyperbolefile ".hypb" "DEMO" "Smart_Mouse_Keys")
but I couldn't find - yet - a function that would show me lots of
information about the explicit button at point without following it.
OOPS, UPDATE: it seems that typing C-h A on a button would sort of do
that - I need to spend some time learning to read its output.
Another problem: the DEMO file refers to some commands that start with
C-h h - for example:
(find-hyperbolefile "DEMO" "HY-ABOUT" "C-h h d a")
(find-hyperbolefile "DEMO" "Hyperbole Glossary of terms" "C-h h d g")
Typing C-h h brings up a menu in the minibuffer that is quite nice to
navigate, but in which most tools that are familiar to me don't
work... for example, if I type C-x 4 C-h I get a buffer that says
this,
Global Bindings Starting With C-x 4:
key binding
--- -------
C-x 4 C-f find-file-other-window
C-x 4 C-o display-buffer
(...)
and I can use this sexp to go back to that listing whenever I want:
(eek "C-x 4 C-h")
but `eek' doesn't work with Hyperbole's C-h h - for example, this just
inserts an `a':
(eek "C-h h d a")
and my default way of creating hyperlinks to an interesting key
sequence stops at `C-h h'...
(find-elongkey-links "C-h h ;; hyperbole")
(eek "M-h M-k C-h h ;; hyperbole")
I'll have to find another way to create hyperlinks to key sequences
like `C-h h d a' and to the function bound to it - possibly by
pointing to code in hui-mini.el...
(find-hyperbolefile "hui-mini.el" "(defun hyperbole ")
(find-hyperbolefile "hui-mini.el" "(defun hyperbole-minibuffer-menu ")
That's it for the moment. I think that the chances of other people
finding Hyperbole difficult to learn for reasons similar to mine are
tiny, but I thought that I should report all this anyway... and any
hints would be welcome, of course...
Cheers!
Eduardo Ochs
http://angg.twu.net/emacsconf2019.html
http://angg.twu.net/eev-intros/find-emacs-keys-intro.html
http://angg.twu.net/eev-intros/find-eev-intro.html#1
#####
#
# koutline
# 2020sep27
#
#####
# «koutline» (to ".koutline")
# (require 'hyperbole)
# (code-c-d "hyperbole" "~/.emacs.d/elpa/hyperbole-7.1.2/" "hyperbole")
# (find-hyperbolefile "HY-ABOUT")
# (find-hyperbolefile "HY-ABOUT" "1. Buttons and Smart Keys")
# (find-hyperbolefile "DEMO")
# (find-hyperbolefile "DEMO" "demonstration of the Koutliner")
# (find-hyperbolefile "DEMO" "C-h h k e")
# (find-hyperbolefile "hui-mini.el" "Kotl>")
# (find-hyperbolefile "hui-mini.el" "Kotl>" "Examp")
# (find-hyperbolefile "kotl/kotl-mode.el" "defun kotl-mode:example ")
# (find-hyperbolenode "Koutliner")
# (find-hyperbolenode "Koutliner Keys")
# (find-hyperbolenode "Koutliner Keys" "kotl-mode:example")
# (find-fline "~/EXAMPLE.kotl")
#####
#
# Bring Your Text to Life the Easy Way with GNU Hyperbole
# 2020sep27
#
#####
# «bring-your-text-to-life» (to ".bring-your-text-to-life")
# https://emacsnyc.org/2020/08/13/bring-your-text-to-life-the-easy-way-with-gnu-hyperbole.html
# https://www.reddit.com/r/emacs/comments/i9kscx/emacs_nyc_video_release_bring_your_text_to_life/
# https://www.youtube.com/watch?v=nC1eTgZE1oA
# (code-video "bythyperbolevideo" "/sda5/videos/Bring_Your_Text_to_Life_the_Easy_Way_with_GNU_Hyperbole-nC1eTgZE1oA.webm")
# (find-bythyperbolevideo)
# (find-bythyperbolevideo "0:00")
# (find-bythyperbolevideo "1:16")
# (find-bythyperbolevideo "2:50" "Engelbart")
# (find-bythyperbolevideo "5:10" "Why should you use")
# (find-bythyperbolevideo "6:57" "Components")
# (find-bythyperbolevideo "9:53" "Installation")
# (find-bythyperbolevideo "11:03" "Mouse")
# (find-bythyperbolevideo "11:52" "So")
# (find-bythyperbolevideo "15:28" "Buttons")
# (find-bythyperbolevideo "16:23" "Implicit buttons (to bug#5320)")
# (find-bythyperbolevideo "16:35" "6 lines of code")
# (find-bythyperbolevideo "17:00" "Three categories of buttons")
# (find-bythyperbolevideo "18:19" "arbitrary actions")
# (find-bythyperbolevideo "19:06" "a few common examples (pathnames, key series)")
# (find-bythyperbolevideo "19:53" "global buttons")
#####
#
# "Hyperbole and eev" - my email (2020sep27)
# 2020sep27
#
#####
# «hyp-and-eev-2020sep27» (to ".hyp-and-eev-2020sep27")
# https://lists.gnu.org/archive/html/hyperbole-users/2020-09/msg00009.html rsw
# https://lists.gnu.org/archive/html/hyperbole-users/2020-09/msg00013.html edrx
# https://mail.google.com/mail/ca/u/0/#sent/QgrcJHrnsbvVQCkPzjXcrNBgnlLGMqwvPjV
Hi Robert,
I will try to answer all your e-mails in a single e-mail - in a new
thread. Yor e-mails are here:
https://lists.gnu.org/archive/html/hyperbole-users/2020-09/index.html#00008
First: thanks for the hints, things are starting to make sense to me.
We are clearly using different notions of simplicity - eev is like a
Volkswagen Beetle, in the sense that if you open its lid everything is
trivial to figure out and to fix, hack, and extend.
It's nice that you said
> I really, really recommend that you try to use Hyperbole without
> initially mixing it with eev, as I think you will find that
> Hyperbole already contains much of what you need to simplify eev and
> tie it to a broader Emacs ecosystem.
because that sort of allows me to ask you to try eev! =) =) =)
I am not going to ask you to try eev without Hyperbole, though - I
tried to
1. make eev as non-invasive as possible - see:
http://angg.twu.net/eev-intros/find-eev-intro.html#1
2. make it trivial to navigate by people who have very short
attention spans and who have just a few spare minutes to play
with it. Here are the instructions:
a. install eev with M-x list-packages,
b. run M-x eev-beginner,
c. learn how to use M-e and M-j to navigate the docs. See:
http://angg.twu.net/eev-intros/find-emacs-keys-intro.html#1
Let me copy that section here:
1. Basic keys (eev)
===================
The most basic keys of eev are:
M-e - to follow a hyperlink. Mnemonic: "(e)valuate"/"(e)xecute".
See: (find-eev-quick-intro "2. Evaluating Lisp")
(find-eev-quick-intro "3. Elisp hyperlinks")
M-j - to jump to certain predefined places. In particular,
`M-j' takes you to a buffer with basic help and a
list of jump targets. See:
(find-eev-quick-intro "7.2. The list of eejump targets")
`M-2 M-j' takes you to this help page.
`M-5 M-j' takes you to: (find-eev-quick-intro)
M-k - to go back. Mnemonic: "(k)ill buffer".
See: (find-eev-quick-intro "3. Elisp hyperlinks" "M-k")
By the way, you asked me what this line of my e-mail does:
(code-c-d "hyperbole" "~/.emacs.d/elpa/hyperbole-7.1.2/" "hyperbole")
The answer is here:
(find-eev-quick-intro "9.1. `code-c-d'")
You can see the code that it runs by running this:
(find-code-c-d "hyperbole" "~/.emacs.d/elpa/hyperbole-7.1.2/" "hyperbole")
We are following different design principles. In my view, or, in eev's
view, Hyperbole uses an awful amount of markup syntax, and it keeps
the Elisp code too far from the user. Let me give you two examples,
and ask you a question about a technical point in which I am stuck.
I am watching your video
"Bring Your Text to Life the Easy Way with GNU Hyperbole"
http://www.youtube.com/watch?v=nC1eTgZE1oA
and I am indexing it with the tricks described here:
http://angg.twu.net/eev-intros/find-audiovideo-intro.html#4.3
The video made me understand that Hyperbole's action key works on
{Implicit Buttons}, <(Explicit Buttons)>, and <(Global Buttons)> -
from 17:00 in the video onwards - and from 19:06 onwards you show that
the action key also works on pathnames enclosed in double quotes, in a
way that supports lots of abbreviations. That's REALLY nice - but let
me point to you that eev's hyperlinks can to point to arbitrary
positions in files, manpages, PDFs, etc, and I don't know if the "#"
syntax in Hyperbole's hyperlinks can do that... see:
http://angg.twu.net/eev-intros/find-refining-intro.html
http://angg.twu.net/eev-intros/find-pdf-like-intro.html#4
Ok, time for my technical question. Apparently this Hyperbole button
{C-h h d a}
should have essentially the same action as:
(eek "C-h h d a")
but my `eek' sexp just inserts an "a". It's trivial to inspect the
innards of how the function eek works - we just have to search for its
source code, and it is just this:
(defun eek (str) (interactive "sKeys: ")
"Execute STR as a keyboard macro. See `edmacro-mode' for the exact format.\n
An example: (eek \"C-x 4 C-h\")"
(execute-kbd-macro (read-kbd-macro str)))
Your key sequence buttons work well on key sequences like {C-h h d a},
but I couldn't find a function that on receiving the string like "C-h
h d a" would execute it as a key sequence, like this would do,
(execute-kbd-macro (read-kbd-macro "C-h h d a")))
but without the bugs... I grepped for "key sequence" in the Hyperbole
source directory and created a link to the result of that grep,
(find-hyperbolegrep "grep --color -niH --null -e 'key sequence' *.el")
to be able to go back to that easily. I guess that the function that I
am looking for is in:
(find-hyperbolefile "hib-kbd.el")
but I couldn't find it... and typing C-h A didn't help me much. I have
the feeling that C-h A would be better if it would say which function
the action key would call - I mean, something more precise than saying
"hui:hbut-act".
Cheers,
Eduardo Ochs
http://angg.twu.net/emacsconf2019.html
#####
#
# hyp-and-eev-2020sep30
# 2020sep30
#
#####
# «hyp-and-eev-2020sep30» (to ".hyp-and-eev-2020sep30")
# (require 'hyperbole)
# (find-efunction 'actypes::kbd-key)
# (find-efunction 'hact)
You want this:
(actypes::kbd-key "C-h h d a")
because to translate the 'defact' 'kbd-key' to an actual function, you
prefix it with 'actypes::'.
Or you could simply use the generalized form of an implicit button
which replaces the outer parens of an sexp with angle brackets:
<kbd-key "C-h h d a">
Hyperbole keeps it simple.
(...)
Hmm. When I use {C-h A} on {C-h h d a} it shows me both the implicit
button type:
categ: ibtypes::kbd-key
and the action type:
actype: kbd-key
Maybe we should show the actypes:: prefix too so you can more easily
know what function to run manually but in the Hyperbole world you
invoke actypes with the hact macro, as in:
(hact 'kbd-key "C-h h d a")
#####
#
# GNU Hyperbole V8: Rocket Through Your Information with Buttons (Emacs-Elements)
# 2021may09
#
#####
# «rocket-buttons» (to ".rocket-buttons")
# https://www.youtube.com/watch?v=UMANdTBvQUY
#####
#
# hyp-and-org-2022jun20
# 2022jun20
#
#####
# «o-h-and-e-524» (to ".o-h-and-e-524")
# «hyp-and-org-2022jun20» (to ".hyp-and-org-2022jun20")
# https://lists.gnu.org/archive/html/emacs-orgmode/2022-06/msg00524.html edrx
# https://lists.gnu.org/archive/html/emacs-orgmode/2022-06/msg00528.html juan
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
#####
#
# hyp-disable-2022jun23
# 2022jun23
#
#####
# «hyp-disable-2022jun23» (to ".hyp-disable-2022jun23")
# https://lists.gnu.org/archive/html/emacs-orgmode/2022-06/msg00632.html
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
#####
#
# on-and-off
# 2022jun26
#
#####
# «on-and-off» (to ".on-and-off")
(package-initialize)
(package-refresh-contents)
(package-install 'hyperbole)
# (find-epackage-links 'hyperbole "hyperbole" t)
# (find-epackage 'hyperbole)
# (code-c-d "hyperbole" "~/.emacs.d/elpa/hyperbole-8.0.0/")
# (find-hyperbolefile "")
# (find-node "(hyperbole)")
# (find-node "(hyperbole)Implicit Button Types")
# (find-node "(hyperbole)Manual Overview" "C-h h d d")
# (find-hyperbolefile "FAST-DEMO")
# (find-hyperbolefile "FAST-DEMO" "Introductory Videos")
# (find-youtubedl-links "/sda5/videos/" "GNU_Hyperbole_-_Overview_and_Demo" "WKwZHSbHmPg" ".webm" "hypoandd")
# (code-video "hypoanddvideo" "/sda5/videos/GNU_Hyperbole_-_Overview_and_Demo-WKwZHSbHmPg.webm")
# (find-hypoanddvideo "0:00")
# (find-yttranscript-links "hypoandd" "WKwZHSbHmPg")
"-subr.el"
"subr.el"
{C-h h d d}
# (package-delete (ee-package-desc 'hyperbole))
# (find-efunctiondescr 'hyperbole)
# (find-efunction 'hyperbole)
# (find-efunctiondescr 'hyperbole-mode)
# (find-efunction 'hyperbole-mode)
# (find-evariable-links hyperbole-mode-map)
# (find-hvariable 'hyperbole-mode-map)
# (find-ekeymapdescr hyperbole-mode-map)
# (find-hyperbolegrep "grep --color=auto -nH --null -e global-set-key *.el")
# (find-efunctiondescr 'hkey-initialize)
# (find-efunction 'hkey-initialize)
# (find-efunction 'hkey-initialize "(vector help-char ?h)")
# (find-evariable-links hkey-init)
# (find-evardescr 'hkey-init)
# (find-evariable 'hkey-init)
# (find-customizegroup 'hyperbole)
# (find-customizegroup 'hyperbole-keys)
# (find-customizevariable 'hkey-init)
#####
#
# How M-RET on a <...> button runs ibtypes::action
# 2022jun28
#
#####
# «M-RET-on-action-button» (to ".M-RET-on-action-button")
# https://lists.gnu.org/archive/html/emacs-orgmode/2022-06/msg00757.html Edrx 3
# https://lists.gnu.org/archive/html/emacs-orgmode/2022-06/msg00765.html Rsw 7
# (find-angg ".emacs" "ee-eval-defun-test")
(code-c-d "hyperbole" "~/.emacs.d/elpa/hyperbole-8.0.0/")
(require 'hyperbole)
(hyperbole-mode 0)
(find-hyperbolefile "DEMO")
(find-hyperbolefile "DEMO" "Action Key is {M-RET}")
(find-hyperbolegrep "grep -nH --null -e M-RET *")
(find-efunction 'hkey-initialize)
(find-efunction 'hkey-initialize "Bind the Action Key to {M-RET}")
(find-ekeymapdescr hyperbole-mode-map)
(find-ekeymapdescr hyperbole-mode-map "M-RET")
(find-ekeymapdescr hyperbole-mode-map "M-RET" "hkey-either")
(find-efunction 'hkey-either)
(find-efunction 'assist-key)
(find-efunction 'assist-key-internal)
(find-efunction 'action-key)
(find-efunction 'action-key-internal)
(find-efunction 'hkey-execute)
(find-efunction 'hkey-execute "hkey-alist")
(find-evardescr 'hkey-alist)
(find-eppp hkey-alist)
(find-eppp hkey-alist "(hbut:at-p)")
(find-evariable 'hkey-alist)
(find-evariable 'hkey-alist "If on a Hyperbole button")
(find-evariable 'hkey-alist "If on a Hyperbole button" "(hbut:at-p)")
(find-efunction 'hbut:at-p)
(find-efunction 'hbut:at-p "ebut:at-p")
(find-efunction 'hbut:at-p "ibut:at-p")
(find-efunction 'ebut:at-p)
(find-efunction 'ebut:get)
(find-efunction 'ibut:at-p)
https://lists.gnu.org/archive/html/emacs-orgmode/2022-06/msg00765.html
^ mentions ibtypes::action and defib action
(find-efunction 'defib)
(find-hyperbolegrep "grep --color=auto -nH --null -e defib *.el")
(find-hyperbolegrep "grep -a -nH --null -e defib hibtypes.el")
(find-hyperbolefile "hibtypes.el" "(defib action")
(progn
(find-hyperbolefile "hibtypes.el" "(defib action")
(end-of-defun)
(setq ee-defib-defun (ee-last-sexp))
)
(find-estring ee-defib-defun)
(find-epp (read ee-defib-defun))
(find-eppm (read ee-defib-defun))
(find-efunction 'htype:create)
(find-efunction 'htype:symbol)
(htype:symbol 'action 'ibtypes)
(find-efunction 'ibtypes::action)
(find-efunctionpp 'ibtypes::action)
(load "hibtypes.elc")
(load "hibtypes.el")
(find-efunctionpp 'ibtypes::action)
(hyperbole-mode 1)
(debug-on-entry 'ibtypes::action)
(eek "2*<down> C-e <left>")
(eek "<down> C-e <left> M-RET")
<insert "foo">
(hyperbole-mode 0)
(find-efunction 'ibut:at-p)
(find-efunction 'ibut:at-p "(funcall itype)")
(find-eppp (htype:category 'ibtypes))
(find-hyperbolegrep "grep -a -nH --null -e defib hibtypes.el")
(find-efunction 'symtable:add)
(find-evardescr 'symtable:ibtypes)
(find-evariable 'symtable:ibtypes)
#####
#
# Org, Hyperbole, and eev - find-here-links
# 2022jun28
#
#####
# «o-h-and-e-738» (to ".o-h-and-e-738")
# https://lists.gnu.org/archive/html/emacs-orgmode/2022-06/msg00738.html
Hi all,
this message is slightly off-topic, and a shameless plug...
Eev can do many things that Org and Hyperbole and do, but it makes
very little sense to people who can play the role of "users" well, in
the sense of people who can "use" Emacs packages without looking at
the elisp source and hacking it, i.e.: reading the source of the
package, inspecting and understanding its data structures, and
creating sexps that call the package's functions directly...
Eev still has a couple of parts whose data structures are hard to
inspect. I don't regard these parts as "real" bugs, but I do regard
them as hugely embarassing - and I have just fixed one of them:
`find-here-links', that is explained in this section of the main
tutorial,
http://angg.twu.net/eev-intros/find-eev-quick-intro.html#4.1
and in this other tutorial:
http://angg.twu.net/eev-intros/find-here-links-intro.html
The way to run `find-here-links' in debug mode is explained here,
http://angg.twu.net/eev-current/eev-hlinks.el.html
in the second part of the ";;; Commentary:" at the top - look for
"Debug mode".
As I mentioned in the other thread
https://lists.gnu.org/archive/html/emacs-orgmode/2022-06/msg00524.html
https://lists.gnu.org/archive/html/emacs-orgmode/2022-06/threads.html#00524
and in these pages,
http://angg.twu.net/2021-org-for-non-users.html
http://angg.twu.net/find-elisp-intro.html
http://angg.twu.net/eev-wconfig.html
http://angg.twu.net/hyperbole.html
I find Org and Hyperbole difficult mainly because they are
hacker-unfriendly. It _may be_ that some of the people who said that
they find Org very hard in this thread
https://lists.gnu.org/archive/html/emacs-devel/2022-06/threads.html#00186
would also benefit from a bit more of hacker-friendliness... and so it
would be great if more ideas could flow between Org, eev, and Hyperbole.
Cheers and sorry the noise =P,
Eduardo Ochs
http://angg.twu.net/#eev
#####
#
# Org, Hyperbole, and eev - something useful to say
# 2022jun28
#
#####
# «o-h-and-e-742» (to ".o-h-and-e-742")
# https://lists.gnu.org/archive/html/emacs-orgmode/2022-06/msg00742.html
On Sun, 26 Jun 2022 at 13:29, Robert Weiner <[email protected]> wrote:
> Hi Eduardo:
>
> I really think that you are confused in saying that Hyperbole and Org are
> hacker-unfriendly. Yes, they are targeted at users who don't have to
> understand the programming, but if you do understand Lisp programming well,
> the interactive features are available as Lisp functions in almost all cases,
> so you simply have to dive in, find the functions you want and utilize or
> change them.
>
> In fact, Hyperbole offers 'action implicit buttons' that utilize
> angle-bracket syntax to turn any Lisp function (or hyperbole button type call
> or variable reference) into a hyperbutton that runs the function with
> arguments or displays the variable, e.g. <find-file
> "~/.org/my-org-file.org">.
>
> With Hyperbole, much of the behavior is factored into class-like libraries
> with the 'methods' alphabetized and separated into public and private
> groupings. Now some of this code is complex in order to handle many contexts
> and make things simple to the user but that is a matter of you understanding
> this complexity if you want to hack on it.
>
> I'm not sure what else you could ask for in packages.
Hi Robert,
let me see if I can find something useful to say...
Most of the people that I know who became active users of eev were
"beginner programmers" when they started using eev - by "beginner
programmers" I mean that their mental buffers were still quite small,
and they couldn't understand well functions that were more than a few
lines long. I wanted to make eev more accessible to people like them,
and I treated their feedback very seriously.
One of the techniques that I used to make eev more accessible to them
is described in this video,
http://angg.twu.net/find-elisp-intro.html
(find-1stclassvideo-links "2022findelispintro")
(find-2022findelispintrovideo "14:36")
from 14:36 onwards - "put several similar examples close to one
another, starting by the most basic ones".
I treated that technique as "obvious" for many years - I just used it
in many places, and I thought that the users would notice that
pattern, and start to use it in their own notes. That didn't work, and
I saw that I had to spell out that technique explicitly, and repeat it
often.
When I asked you questions about how to create eev-style sexps that
would behave as hyperbole-style buttons, in some of the e-mails that I
point to here,
http://angg.twu.net/hyperbole.html
I was signaling that my mental buffers were almost full... at that
point explanations in English helped me very little, and I was trying
to write "several similar examples close to one another, starting by
the most basic ones" to factor your code conceptually via tests.
I _still_ think that your buttons and menus are hacker-unfriendly. The
source code is available, yes, but I spent several evenings trying to
understand them in my "non-user" way, and I got a mental buffer
overflow instead of enlightenment... and I also spent many hours
writing e-mails to the Hyperbole mailing list, but the answers left me
very frustrated.
Hope that helps, =/
Eduardo Ochs
http://angg.twu.net/#eev
#####
#
# Org, Hyperbole, and eev - let me propose three tasks
# 2022jun28
#
#####
# «o-h-and-e-750» (to ".o-h-and-e-750")
# https://lists.gnu.org/archive/html/emacs-orgmode/2022-06/msg00750.html
On Sun, 26 Jun 2022 at 15:23, Robert Weiner <[email protected]> wrote:
>
> Maybe if you could pick a single eev function that you think could
> be implemented with Org and Hyperbole and pointed us to the
> documentation for that, then we could show you an equivalent one
> using these packages and begin to give you a better sense of how you
> would go about leveraging what has been built. You document
> everything in detail, so this should be pretty simple.
I am not sure if I understood your proposal correctly, but let me
propose three tasks that would be pretty natural in eev-land... In all
cases below "explain" means "explain step by step, with links to the
source code and to the docs, and with sexps that inspect the data
structures".
1) explain what happens when we type M-RET on this button:
"subr.el"
2) explain what happens when we type:
C-h h d d
3) suppose that we have a function that plays a local copy of your
video "GNU Hyperbole - Overview and Demo". Let's use this fake
function instead of a real one:
;; Test: (fake-play-oand "2:34")
;;
(defun fake-play-oand (time &rest comments)
(move-beginning-of-line 2)
(insert (format "[Play Overview and Demo from: %s]\n" time)))
Explain how you would implement buttons - choose your favorite
syntax for them - that play "GNU Hyperbole - Overview and Demo"
starting from a given timemark.
Is that a good starting point? Note the unusual meaning for
"explain"... how would you use Hyperbole to prepare these
"explanations"?
> From my perspective, I do really like your idea of replayable
> notebooks for training and interaction purposes. And you have
> certainly made that easy to use via eev. But your implementation
> could use much better organization and abstraction which would
> likely greatly reduce the code size as well. You should separate out
> computation of what you want to display from how and where you will
> display it as one technique.
I'm very interested in seeing your suggestions! Can you be more
concrete?
[[]],
Eduardo Ochs
http://angg.twu.net/#eev
#####
#
# Org, Hyperbole, and eev - That's bad news
# 2022jun28
#
#####
# «o-h-and-e-757» (to ".o-h-and-e-757")
# https://lists.gnu.org/archive/html/emacs-orgmode/2022-06/msg00757.html
# See also: https://lists.gnu.org/archive/html/eev/2022-06/msg00014.html
On Sun, 26 Jun 2022 at 17:24, Robert Weiner <[email protected]> wrote:
>
> That was not the offer. The offer was to show you how to implement a
> discrete eev command using another framework, possibly simplifying
> its implementation. Hopefully, from seeing the code used to do this,
> you could dig in yourself and follow the flow to whatever level you
> like. Hyperbole, for example, has been implemented across years of
> part-time work. Of course, it has complexities in its implementation
> and if the non-abstract parts of that interest you, then use edebug
> or trace commands to explore the code flow but I wouldn't expect
> anyone to write that out for you.
Hi Robert,
That's bad news. In the last years I became a specialist on helping
people with the "non-abstract parts", usually via chat... we discuss
until we find together what are the parts that are not clear to them,
them we write tests that show how those parts work, and then we go
back to the high-level functions.
In eev the two sexp hyperlinks below
(find-efunction 'hkey-initialize)
(find-efunction 'hkey-initialize "Bind the Action Key to {M-RET}")
point to the source code of `hkey-initialize', but the second one is a
"refinement" of the first one in this sense:
(find-refining-intro)
http://angg.twu.net/eev-intros/find-refining-intro.html
I often use sequences of sexp hyperlinks, with and without
refinements, to record an "explanation" of how something is done. For
example, this block
(code-c-d "hyperbole" "~/.emacs.d/elpa/hyperbole-8.0.0/")
(find-hyperbolefile "DEMO")
(find-hyperbolefile "DEMO" "Action Key is {M-RET}")
(find-hyperbolegrep "grep -nH --null -e M-RET *")
(find-efunction 'hkey-initialize)
(find-efunction 'hkey-initialize "Bind the Action Key to {M-RET}")
(find-ekeymapdescr hyperbole-mode-map)
(find-ekeymapdescr hyperbole-mode-map "M-RET")
(find-ekeymapdescr hyperbole-mode-map "M-RET" "hkey-either")
(find-efunction 'hkey-either)
(find-efunction 'assist-key)
(find-efunction 'assist-key-internal)
(find-efunction 'action-key)
(find-efunction 'action-key-internal)
(find-efunction 'hkey-execute)
(find-efunction 'hkey-execute "hkey-alist")
(find-evardescr 'hkey-alist)
(find-eppp hkey-alist)
(find-evariable 'hkey-alist)
(find-evariable 'hkey-alist "If on a Hyperbole button")
(find-efunction 'hbut:at-p)
(find-efunction 'hbut:at-p "ebut:at-p")
(find-efunction 'hbut:at-p "ibut:at-p")
(find-efunction 'ebut:at-p)
(find-efunction 'ebut:get)
(find-efunction 'ibut:at-p)
is an attempt to understand how M-RET treats hkey-alist as a kind of
program to be run...
How would you rewrite the sexps above as Hyperbole buttons?
I downloaded a local copy of
(find-hyperbolefile "FAST-DEMO")
(find-hyperbolefile "FAST-DEMO" "GNU Hyperbole Videos")
(find-hyperbolefile "FAST-DEMO" "Overview and Demo")
(find-hyperbolefile "FAST-DEMO" "https://youtu.be/WKwZHSbHmPg";)
with
(find-youtubedl-links nil nil "WKwZHSbHmPg" nil "hoandd")
Docs: (find-efunction 'find-youtubedl-links)
and I found - via the transcript -
(find-yttranscript-links "hoandd" "WKwZHSbHmPg")
Docs: (find-efunction 'find-yttranscript-links)
that starting on 5:14
(find-hypoanddvideo "05:14" "and so it's very easy to create these")
(find-hypoanddvideo "05:17" "live")
(find-hypoanddvideo "05:18" "uh interactive tutorials if you want")
you say that you can use Hyperbole buttons to create interactive
tutorials... I do that with eev all the time, but my "buttons" are
sexps.
Imagine for a moment that a group of, say, 42 Emacs users asks you to
prepare a video tutorial on how exactly hkey-alist works, because they
want to create their own extensions - button types? - and they think
that it would be nice, and useful to the world, etc, etc, if you could
record a video explaining that... would you still answer something
like this,
"then use edebug or trace commands to explore the code flow but I
wouldn't expect anyone to write that out for you"
or would you use Hyperbole to create an interactive tutorial
explaining the details, and record a video demo-ing it?
[[]] =/,
Eduardo Ochs
http://angg.twu.net/#eev
#####
#
# Org, Hyperbole, and eev - my message about M-RET
# 2022jun28
#
#####
# «o-h-and-e-801» (to ".o-h-and-e-801")
# https://lists.gnu.org/archive/html/emacs-orgmode/2022-06/msg00801.html
On Mon, 27 Jun 2022 at 01:11, Robert Weiner <[email protected]> wrote:
>
> These are Action buttons run by the action button type defined via
> the defib macro in the “hibtypes.el” file. Just search for ‘defib
> action’ in there. You can invoke its implicit button type function
> from Lisp as (ibtypes::action) if I recall.
Hi Robert and other people,
I was finally able to understand a significant part of what happens
when we type M-RET on an action button like
<insert "foo">
with hyperbole-mode active... my notes are here - for the sake of
completeness; I don't expect them to be readable -
(code-c-d "hyperbole" "~/.emacs.d/elpa/hyperbole-8.0.0/")
(require 'hyperbole)
(hyperbole-mode 0)
(find-hyperbolefile "DEMO")
(find-hyperbolefile "DEMO" "Action Key is {M-RET}")
(find-hyperbolegrep "grep -nH --null -e M-RET *")
(find-efunction 'hkey-initialize)
(find-efunction 'hkey-initialize "Bind the Action Key to {M-RET}")
(find-ekeymapdescr hyperbole-mode-map)
(find-ekeymapdescr hyperbole-mode-map "M-RET")
(find-ekeymapdescr hyperbole-mode-map "M-RET" "hkey-either")
(find-efunction 'hkey-either)
(find-efunction 'assist-key)
(find-efunction 'assist-key-internal)
(find-efunction 'action-key)
(find-efunction 'action-key-internal)
(find-efunction 'hkey-execute)
(find-efunction 'hkey-execute "hkey-alist")
(find-evardescr 'hkey-alist)
(find-eppp hkey-alist)
(find-eppp hkey-alist "(hbut:at-p)")
(find-evariable 'hkey-alist)
(find-evariable 'hkey-alist "If on a Hyperbole button")
(find-evariable 'hkey-alist "If on a Hyperbole button" "(hbut:at-p)")
(find-efunction 'hbut:at-p)
(find-efunction 'hbut:at-p "ebut:at-p")
(find-efunction 'hbut:at-p "ibut:at-p")
(find-efunction 'ebut:at-p)
(find-efunction 'ebut:get)
(find-efunction 'ibut:at-p)
https://lists.gnu.org/archive/html/emacs-orgmode/2022-06/msg00765.html
^ mentions ibtypes::action and defib action
(find-efunction 'defib)
(find-hyperbolegrep "grep --color=auto -nH --null -e defib *.el")
(find-hyperbolegrep "grep -a -nH --null -e defib hibtypes.el")
(find-hyperbolefile "hibtypes.el" "(defib action")
(progn
(find-hyperbolefile "hibtypes.el" "(defib action")
(end-of-defun)
(setq ee-defib-defun (ee-last-sexp))
)
(find-estring ee-defib-defun)
(find-epp (read ee-defib-defun))
(find-eppm (read ee-defib-defun))
(find-efunction 'htype:create)
(find-efunction 'htype:symbol)
(htype:symbol 'action 'ibtypes)
(find-efunction 'ibtypes::action)
(find-efunctionpp 'ibtypes::action)
(load "hibtypes.elc")
(load "hibtypes.el")
(find-efunctionpp 'ibtypes::action)
(hyperbole-mode 1)
(debug-on-entry 'ibtypes::action)
(eek "2*<down> C-e <left>")
(eek "<down> C-e <left> M-RET")
<insert "foo">
(hyperbole-mode 0)
(find-efunction 'ibut:at-p)
(find-efunction 'ibut:at-p "(funcall itype)")
(find-eppp (htype:category 'ibtypes))
(find-hyperbolegrep "grep -a -nH --null -e defib hibtypes.el")
(find-efunction 'symtable:add)
(find-evardescr 'symtable:ibtypes)
(find-evariable 'symtable:ibtypes)
I still don't understand well the code of ibut:at-p between the
beginning and the point in which it calls (funcall itype), and I also
don't understand well the code of ibtypes::action...
Anyway, we are clearly using different notions of simplicity - see:
https://lists.gnu.org/archive/html/hyperbole-users/2020-09/msg00013.html
and I find it enviable that you can have that kind of complexity under
the hood and still have lots of users that agree that Hyperbole is
"simple"...
Most people find eev very weird, and I have the impression that I
wouldn't have half of my (few) users if I had code like that in eev.
If the people who like to look under the hood try to understand how
M-e in eev works they will end up trying to understand how
(forward-sexp -1)
works, and then they will read the comments of scan-sexps in
syntax.c... syntax.c is impeccably well-written, and they will
probably feel that their time was very well spent, and that their
curiosity has lead them to very good places. =\
Exhausted cheers,
Eduardo Ochs
http://angg.twu.net/#eev
#####
#
# Org, Hyperbole, and eev - my message about tests in comments
# 2022jun28
#
#####
# «o-h-and-e-802» (to ".o-h-and-e-802")
# https://lists.gnu.org/archive/html/emacs-orgmode/2022-06/msg00802.html
On Sun, 26 Jun 2022 at 21:50, Robert Weiner <[email protected]> wrote:
>
> So here is a simple implementation that is not unlike your own
> though the functions are a bit simpler and more clearly documented
> _without a listing of every possible test case type_ and requires
> neither Hyperbole nor Org until you want to activate things as
> buttons:
Hi Robert,
I think that the part in "_..._"s above deserves a detailed answer.
I started using GNU/Linux in the mid-90s. Before that my favorite
languages were Icon and Forth. In Forth I could do AMAZING things in
less than 50 lines of code, but my programs would usually become
confusing and unmanageable when they grew bigger than that.
There is a famous book by Fred Brooks called "The Mythical Man-Month",
and one of its chapters is called "Plan to Throw One Away":
https://wiki.c2.com/?PlanToThrowOneAway
I took that slogan seriously. Most of the time when I realized that
something that I was doing by hand could be automated I would write a
first attempt to automate it - _as a prototype_, that I regarded
partly a program and partly as a way to help me think how that task
could be structured, and that would probably be "thrown away" if I
needed a cleaner solution later.
In Forth it was very easy to implement both strange interfaces and
little languages, in this sense:
https://wiki.c2.com/?LittleLanguage
In Emacs less so, but I could still do lots of funny things using
eval-last-sexp to use sexps as buttons.
When we are writing throwaway code "planning to throw one away" then
using tests in comments is a very good way to document the code. And
when I rewrite my prototypes I usually prefer to document them using
text ***AND*** executable examples rather than just text. One of the
effects of using this style is that the users of eev see that they can
use that style in their notes too - and with that their notes become
much closer to being "executable notes", in this sense,
http://angg.twu.net/eev-intros/find-here-links-intro.html
than they would be if they believed that they had to write the docs of
their functions as just text.
You are sort of saying that having tests in comments is bad style.
Well, it's not. =/
[[]],
Eduardo Ochs
http://angg.twu.net/#eev
#####
#
# hypobole
# 2022jun28
#
#####
# «hypobole» (to ".hypobole")
# https://www.reddit.com/r/emacs/comments/vied1y/gnu_hypobole_10/
https://www.youtube.com/watch?v=R3G-bLHz_S0
# (find-hyperbolegrep "grep --color -niH --null -e 'hycontrol' *.el")
# (find-hyperbolegrep "grep --color -niH --null -e 'key sequence' *.el")
# (find-hyperbolegrep "grep --color -niH --null -e 'load-path' *.el")
# (find-hyperbolefile "hversion.el" "(locate-file file load-path")
# (find-bythyperbolevideo "17:00" "Three categories of buttons")
https://www.reddit.com/r/emacs/comments/vhc8l1/gnu_hyperbole_many_have_heard_of_it_but_what_does/
https://www.reddit.com/r/emacs/comments/jk3cn0/daily_ways_gnu_hyperbole_helps_me_stay_in_flow/
Doug Engelbart Institute - Boosting mankind's capability for coping with complex, urgent problems
https://www.dougengelbart.org/
Draft OHS-Project Plan
https://web.archive.org/web/20070704185333/http://www.bootstrap.org/augdocs/bi-2120.html
TECHNOLOGY TEMPLATE PROJECT OHS Framework
https://www.dougengelbart.org/content/view/110/460/
Addressing Hyperdocument Content And Structure
https://www.dougengelbart.org/content/view/110/460/#2b1
Toward High-Performance Organizations A Strategic Role for Groupware
https://www.dougengelbart.org/content/view/116/#7j
About Dynamic Knowledge Repositories (DKR)
https://www.dougengelbart.org/content/view/190/163/
https://www.reddit.com/r/emacs/comments/n3oqle/gnu_hyperbole_v8_rocket_through_your_information/
https://lists.gnu.org/archive/html/hyperbole-users/2022-05/msg00000.html release 8
* hyperbole: hyrolo
https://github.com/termitereform/JunkPile/blob/master/HyperboleNotes2.org
https://tilde.town/~ramin_hal9001/articles/intro-to-hyperbole.html
# Answer to Uzibalqa:
# https://lists.gnu.org/archive/html/help-gnu-emacs/2022-08/msg00188.html
# (code-video "hoanddvideo" "/sda5/videos/GNU_Hyperbole_-_Overview_and_Demo-WKwZHSbHmPg.webm")
# (find-hoanddvideo "0:00")
# Transcript:
# (find-yttranscript-links "hoandd" "WKwZHSbHmPg")
https://www.reddit.com/r/emacs/comments/bua5ex/gnu_hyperbole_703_is_released_and_ready_for_action/
https://www.reddit.com/r/emacs/comments/vhc8l1/gnu_hyperbole_many_have_heard_of_it_but_what_does/
# Local Variables:
# coding: utf-8-unix
# End: