[Speaker 0]: 5 seconds. Oh, actually,
[Speaker 1]: Sorry, I keep delaying.
I keep forgetting that we have an
introduction now. The introduction is flying.
[Speaker 0]: a little more. You're going to give a
[Speaker 1]: Well, it's about 5 seconds now.
[Speaker 0]: 30-second, right? Just say go when you want
[Speaker 1]: Sure. You'll hear me anyway.
[Speaker 0]: me to go. Okay.
[Speaker 1]: All right, I think we are live now.
So hi again, everyone.
I promised you we would be back in about 30
seconds. I lied, it was actually 1 minute,
but we are here with Bob.
Hi, Bob, how are you doing?
[Speaker 0]: Hi, doing great. Glad to
[Speaker 1]: be with you. Yeah, glad to be here,
and so are we. We're glad to have you again
this year. So what we're going to do,
we're not going to waste any time right now
with chit-chats. What we're going to do,
we're going to move straight into your
presentation, Bob, so that you have as much
time as you can. I'm going to recede into the
background. I am going to full screen your
presentation on a stream.
And Bob, the floor is all yours.
[Speaker 0]: Thank you very much, Leo.
Glad to be here. I hope everybody has an idea
of what Hyperbole is, but it's a broad
information management system inside Emacs
that works in all major modes.
It's a global minor mode that you can turn on
and off very rapidly so that you can just get
in and out of hyperbole.
And it works mostly from a mini buffer menu
that if we just hit ctrl H H we see at the
bottom of the screen here and as you see in
some of this text right here,
Dee will show you a demo with all these video
links of Hyperbole now.
But let's just get into the top 10 reasons to
use Hyperbole. Number 10 is a key series
curly braces. So you just put curly braces
around any set of key sequences that you want
and hyperbole magically turns that into what
we call an implicit button a hyper button and
any kind of text that you have so if we go
down here and we just click click here we see
it that was a complex button that said let's
start a shell, let's set an environment
variable as you see the command right up
there, and then let's do a grep over the
hyperbole code and find all instances of a
particular label. So if we hit made a return,
that's called the action key.
That's what you use throughout hyperbole when
you just want to activate any kind of button.
So you see it jumped to the grep output and
this is in a shell buffer it's not in a
compilation buffer so anywhere that you have
this sort of thing it's also an implicit
button and any sort of grep output or
compiler output you can just jump to with the
same key, made a return.
So that's key series, the first part.
And then just to note that you can also just
do a, well I'll just do it here and show you
that you can do a recursive grep with this
hyperbole command, HYPBR grep.
And if you're in an Emacs list buffer,
it will only grep across the Emacs list.
So a very handy way to just go through your
code very rapidly and then jump to various
points in it. So we have a lot to cover
today, so I'm going to go through this
rapidly. This isn't a tutorial,
it's just to get you interested in some of
the features, and then there's a ton of
reference material and videos now available
for Hyperlink. So let's go to number 9.
Path names become implicit buttons.
You don't even have to quote them.
You can add environment variables or elist
variables with the syntax right here.
So here we have a shell script that's
somewhere on our path.
And notice path is an environment variable
with many different paths within it,
right? But Hyperbole knows that and it
searches the path, gets the first match,
finds it, and finds the actual shell script.
So you can just embed that anywhere.
Here we have a list variable,
hyperbdur, which is the home directory for
hyperbole, and then a markdown file,
and a link to a direct section in the file,
and the 5 colon 5 means go to line 5 within
that section and column 5.
So let's just try it. Boom,
we're right there, and we're on another link
that we could activate as well.
So notice the next line is the same link but
this is how you normally have to do it in a
markdown file. You have to change the section
header to have dashes but with hyperbole you
don't have to. You can just put it exactly
like you see it in your file.
Here the pound syntax for sections is really
a generic syntax in the hyperbole.
And so it works in all different kinds of
files, your programming files.
Here's a shell script and we said let's just
go to the first comment that has alias in it.
Notice we didn't have to say the whole line,
just the first part of it.
And it matched to it. Here we have a link to
our hyperbole structured outliner called the
K Outliner. And you can see it auto-numbers
all these cells. But in addition to just
displaying, you can also add a pipe symbol
near the end and use this view syntax to clip
to 2 lines and show blank lines.
So let's see if each node gets clipped to 2
lines. So you see they're all just 2 now with
the ellipses and then we can expand them.
So a lot of power there just with path names.
Let's continue to number 8.
[Speaker 1]: Can I just interrupt you just a bit?
[Speaker 0]: Yes.
[Speaker 1]: I think your phone, so we have your phone set
up in case your internet misbehaves and we've
set this up before we started,
but I think the vibration is a little loud
whenever it does. Can you maybe move it a
little bit? I think so.
It will have to vibrate again.
[Speaker 0]: Is that okay? No, my phone...
Okay. It shouldn't have been vibrating.
[Speaker 1]: have been another device,
but definitely we had vibration.
Anyway, carry on. Sorry for the interruption.
[Speaker 0]: It could be me. It might So number 8,
special prefixes. There are 3 prefixes you
can attach to path names.
The first, if you want to load,
instead of just finding a file,
an ELIST file, you can actually load it.
And so I can just hit made a return on this,
and you see in the mini buffer,
it loaded it as compiled e-list.
I could put a .el on here,
a .elc, .gz, all of that'll work,
and just put a dash in front to load it.
If you want to run a shell command,
just put an exclamation mark in front of
something and again you can have the
environment variable. So here we're saying
run the program date and you see,
let's see, let's do it again.
There we go. It ran date and you see the
output right there. And what if you want to
run a graphical program on your system?
Well here, we want to open a PDF file and I'm
just using XDG Open on Linux,
you could use Open on Mac and you just put an
ampersand in front and there's the Hyperbole
manual instantly displayed.
So lots of power there and all of that
actually .pdf's and many other file types are
automatically linked to various programs by
Hyperbole. So you could just use the path
name itself and it would probably behave the
same way. Number 7, bookmarks on steroids.
So Hyperbole gives you a personal button
file, which is on the menu you see here under
button files, and then personal.
So here we'll just display it.
And you can put whatever you want in here,
these implicit buttons of any type.
You can name them the way here and you can
activate either the name with MetaReturn or
the button itself. So,
of course, if we did MetaReturn here,
we'd just display that in a web browser.
I'll just do a few of these.
So here's a section of line.
Let's just jump there.
But these can be all sorts of different
actions that are going on.
And you just, whatever cross references you
want, you put in here.
And the neat thing is that this then becomes
a list of what we call global buttons.
So when I go into the menu and I go control
HHGA to activate a global button,
you can see that all the names from this file
appear here. So only the name buttons appear,
and I could like go to the hyperbole to-do
list and things like that.
So very, very quick access to all your
information whenever you need it.
And that could be an org file as well if you
prefer that. So we just took care of that.
Number 6, instant test case running and
debugging. This is a fairly new feature.
What we're seeing here is a pre-release of
version 9, which should be out within the
next week. But the instructions at the
beginning of the presentation tell you how to
get the development version of HyperBlade,
which is right now 8.01
pre, but that's virtually the same as what 9
will be. So you can grab that as of today.
So let's just jump to a test file.
What you see here is called an explicit
button. You can actually make buttons where
similar to org, where you just see a bit of
the button and all of the metadata is hidden.
I can say control A J and I see all about
that button, exactly what it's going to do
before I activate it and even who created it
or last modified it. Then just queue out of
here and you're back where you were.
So now, what this did is link us to an ERT
test. If you write tests in Emacs,
you probably use ERT tests.
So if I hit made a return on here it'll just
run the test tell me it passed great okay but
maybe I had a problem so let me use control
you made a return and that will e-debug the
test instantly. So now I'll step through it
and it says, well, let's,
this single line actually creates that
explicit button. You see we have an empty
buffer here that we're in.
Now I step through that and now there's the
explicit button that got put in there.
Now the next line I step through it and this
is going to check if we have the right action
type and it returns true so that's good and
now we should be it should be associated with
the temp buffer returns true good And that's
why what you saw before is this passed.
The whole thing passed.
So lots of power there.
Simple to use. You're just using your made a
return and prefix arguments.
It's something everybody who develops should
have. So number, let's go on.
I think we're making pretty good time here,
but I turned off my timer.
Let's go to number 5. This is a very new
feature, which is very cool too.
You used to have to use the mouse probably
and you could drag across windows to go from
a source to a referent buffer and that would
create a hyperlink for you.
But now we've installed it and made it even
easier on, we've installed it on a,
on the hyperbole menus.
So let's just go back to our presentation
here and say we want to link to this line
that we're on there. And I'll just create the
button in our scratch buffer here so it
doesn't really mess anything up.
So I just put my point in where I want the
button to appear and then I put point where I
want it to link to in the other the other
buffer and then I just say control HH to get
my menu, I for implicit button,
and then L for link. Boom,
it inserts it, right at point.
What did it do? It knew that this was in the
hyperbole directory and I have a variable for
that, so that if you sent this link to your
friend who uses Hyperbole,
it would still work right because they have a
different hyperbole there.
And then I want to go directly to line 116.
So boom, it just took me there.
So that's it. And Hyperbole is doing all this
for you. You just say I want a link to this
thing and it figures out what's at point and
it determines the right type of implicit link
to put there. And that's the whole point is
that you're just working like when you're
programming or you're writing an article and
you just hit made a return or or pull up a
menu and hit a key binding and you're off to
the races. So that was implicit linking We
can also create those explicit link buttons,
and as well as the global link,
where we would just give it a name,
and it would automatically put it in our
global button file without us even having
that on screen. So lots of power there as
well, lots of consistency.
Now let's take a look at the K Outliner a
little more. I'm just going to show you 1
feature actually. I don't have time to show
you the K Outliner in detail,
but it's a really cool structured outliner
that even if you love Org Mode,
you should try it. And this is 1 thing that
you can't get with Org Mode,
is let's say Hyperlink comes with an example
file which teaches you about the K Outliner.
So we'll just use that right here.
And when you're in the K Outliner,
you can bring up and go into the K Outliner
menu right here at the bottom.
And there's a format menu there.
You always take the first letter of a menu,
the first capital letter of a menu item.
So F for format and then D for display in
browser. So just let's do it.
We have with 1 button or 1 key we've produced
the entire outline in a collapsible outline
in HTML. So I can go here.
I just have to use my mouse.
So I can expand and collapse these trees live
with very basic coding.
We tried to keep this as simple as possible.
But you see it maintains the structure of the
outline and even tables.
So all the formatting is maintained and again
it's instant. Or you can just export it to a
file without displaying it.
Very efficient kinds of operations.
So that was number 4. Number 3 is a
subsystem, another subsystem in Hyperbole
called Hycontrol, which is for window and
frame management. And I just wanted to show
you 1 thing in there. It's got a lot of
capabilities. But I always had the problem
that Emacs wouldn't let me scale my fonts,
all of my faces at the same time.
I wanted to zoom. I didn't want to increase
the default font size and all the others stay
the same. So let's just display our faces
right here and then we have a choice of
either controlling frames or windows.
So let's start by controlling frames.
So you get another submenu when you're in
high control to tell you what to do here.
And there's just lowercase z and uppercase z.
So let's try it. So it's scaling the entire
frame. And you can see from the list of faces
that they're all scaling at the same time.
And I can go back down.
Now if I switch to window mode,
and there's a special fast way to do that,
just hit T to toggle. And if you look at the
bottom menu it says frames right now now it
says windows when I hit T so now if I do the
same Z to increase it's just this window and
but it's you know it's the faces in there so
a lot of power again but I just haven't found
anywhere else that you can get that kind of
control over your faces very rapidly.
So that's number 3. Now number 2,
let's put that in there.
So the HiROLO is the final subsystem in
Hyperbole and this has gotten much cooler.
So it started off as a contact management
system, but it's really just a hierarchical
record management system that lets you have
as many files, directories as you want,
and you can search across all of them without
any external utilities necessary,
just what's built into Emacs and Hyperlink.
So as you can see, we've expanded it to
handle org files, markdown,
K outlines, Emacs outlines.
So what I'm going to do is just say,
I want to search using my Hyberlo file list.
You just set that to what you wanted to
search. But now you have all this
flexibility. You can use environment
variables in it. You can just specify a
directory and it will find all those matching
files below that directory recursively.
You can give it the markdown file here and
you can use file wildcards as well.
I mean, look at this. It's got a list
variable in it and a wildcard,
and it's just all I'm gonna do is I change
this from a Lisp expression to make it a
hyper button. You just change the outer
parens to angle brackets,
and then it's automatically an implicit
button that you can activate with made a
return so just ran that and now I've set my
file list so now let's do a search it would
be ctrl H H roll it X R and then S for search
But I'll just do it this way.
And boom, it found everything that fast.
And I can just get like,
show the top items in there.
So I kind of have outlining in this buffer.
I can just move to each match that I hit.
And notice, although everything was
collapsed, it's expanding here.
When I move in and out of each of the entry
matches, it expands or collapses as I move to
the next 1. So a lot of power there.
What else? So just tabbing through these
things. And you notice that it's working
across all of these different types,
and it's telling you which file everything
came from right up here.
So I could just made a return here,
should work. Yes, revisit the file normally.
And it just pulls it right up.
So everything is live and hyperbole.
You've got hyperlinks everywhere.
Let's just get rid of that.
Go back to our demo. So if you are fans of
Vertico and Consult, you can now use that
with the High Rollo. So all you have to do is
let's just format our windows,
and then I'll say, let's use ConsultGrep over
the Rolodex. Now, it found all the matches
there, and I can just move live through them
in the buffer like you may be used to or I
can filter back down and say using orderless
joystick or anything that has joy in it just
match to those lines and then I can you know
either jump there or quit out of here.
I'll just quit out of it right now.
So very cool. And all of that is using
whatever you personally set as the set of
files and directories you want to search.
And finally, our number 1 feature of
Hyperbole is you can customize this to give
you these kinds of implicit buttons,
whatever kind you want.
And there are 3 levels of doing this.
The first is for non-programmers.
You can just set a string,
like a URL with a parameter in it.
So the %s represents the parameter,
and This is how you do a search on
DuckDuckGo. So all I have to do is evaluate
this defal for action link.
And now I have a new implicit button type
that I can put between angle brackets.
And I just give it that name,
DDG, and some parameter,
whatever I want to search for,
and this is a button that does that search.
Very cool, right? So you can embed these.
This could be a hyperlink in,
you know, a comment in a programming file.
Anything on the entire web that you want to
link to, whatever kind of compact notation
you want to give it. So that's what we're
going to learn as we get more advanced here
you can give it even more compact notations.
So as you get more advanced you can say,
well I don't like this angle bracket,
I want to have an implicit button that uses
these square brackets and then an angle
bracket inside it. So then you need the
defile for implicit link.
This lets you specify your start and end
delimiters for your new type and and then you
can give it a function that you wanted to run
and that will take the text of whatever is in
the button, in this case,
test release here, and feed it to the
function that I gave here.
So what this function does is grep over my
git log and find any commits that include the
term test release in it.
So let's try it. First I have to add the
button type and that's all it takes and it
defined it now. So anywhere in Emacs now I
can use this button type essentially.
So let me try to activate it.
Okay, and it says yeah let's save it.
Okay so now it's running a git log command.
It found all the commits and now of course if
I had made a return on this commit it
recognizes it as an implicit link,
and if I search for what was a test release,
there it is. So this commit had that in
there. So all these matches,
so I don't know how other people do this,
but for me this makes it a lot simpler.
So a lot of power that any programmer can
use. And finally, if you've mastered Emacs
Lisp, or you're starting to,
you can look in the hib types file in
Hyperbole and see all sorts of uses of defib,
which is defined implicit button.
And that's the full power of e-LISP when you
want to define 1. So what we're going to do
here is I wanted to know,
given a date, what the day of the week is.
And because the date primitives weren't quite
written the way I might like,
it's a little longer than some.
But I'm just going to evaluate this list.
And I've now defined DOW as an action type.
Now, how do I know I'm doing that?
So I can always say Control-H,
capital A here to see what a button's going
to do. And it tells me When I'm there,
I'm at a hyperbole button,
and the type is from category DOW.
And what's it gonna do?
It takes a mark, it's gonna do a message
action. Okay, so let's try it.
It tells me that's a date,
and it falls on a Sunday,
which is today. That's correct.
So 2 days from today is a Tuesday.
Beautiful. So we've just totally transformed
what we can do with text.
You notice there's no markup here.
And this is working with all of the other
implicit types that we have everywhere in
Emacs. It's only going to match to this kind
of pattern and anywhere else,
you know, it just won't trigger that type.
So lots of power. You just need to get
started with Hyperbole.
There's great documentation both inside the
code and in the manual.
There's a fast demo that you can start with
and there's about 10 different videos.
There'll be 3 presentations on hyperbole here
at the conference, and I hope you've enjoyed
this presentation. I'd love to answer your
questions and get some new users for
Hyperbole. So lastly, I'd like to thank my
co-maintainer, Matt, who's going to speak
later about the extensive test protocols we
have in Hyperbole. Hyperbole works on every
version of Emacs from 27.1
up, and every operating system and Windows
system that you use. And thanks so much to
the volunteers and the speakers at EmacsConf.
You do a great job, and we're all really
appreciative that you take all the time that
you do to make this happen.
Thank you very much.
[Speaker 1]: And thank you so much Bob.
So I'll let you do the gymnastics to join us
back on BBB and put your webcam.
In the meantime, I'll invite people,
as Sasha told you in the introduction,
to go put your question in the pad.
The link is on the talks page and also on
IRC. So take your time.
We've already got some people who've asked
questions. You can also start joining the
room. Let me just ping Sasha.
Ping to open ID HyperAmp.
So, you'll be able to join us on
BigBlueButton as well to go chat with Bob
more directly. I'm not sure if people have
joined already. Not yet.
So, Bob, what I'll do,
we already have 4 questions.
I'm gonna read them to you and you can take
your time answering them,
but we do have about 7 minutes until we go to
the next talk, so we need to be a little bit
[Speaker 0]: Okay.
[Speaker 1]: chop-chop. All right, so reading the first
questions, and I'm also going to display them
for the stream to see,
do buttons keep their metadata within the
same file? E.g., would I see it if I change
to fundamental mode, for instance?
[Speaker 0]: So all of the things that I was showing you,
implicit buttons have no metadata.
That's the great thing about them,
is you just type them in the buffer and what
you see is all there is to that button and
hyperbole generates all the smarts associated
with them. When you create an explicit
button, which I showed you 1 or 2 examples
of, that metadata is, there is metadata with
that, and that is stored in a separate file
in the same directory called .hypb.
So it's hidden away and it doesn't affect the
format of the buffer that it's in.
So again, what you see is what you get.
You just see the delimiters around the
explicit button and that's it.
So Hyperbole takes care of all that for you.
However, if you embed them into like a mail
message, which you can,
you can mail buttons, then there is a hidden
area at the end of the mail message that
encodes the metadata for the explicit
buttons.
[Speaker 1]: Ok, great. Next question.
Is it possible to link to a file by its ID,
like the node, org ID or some similar unique
string inside?
[Speaker 0]: Yes, In fact, that's 1 of the new features in
9. You just made a return on an ID and it
takes you right to the org node,
works with org Rome and org straight out of
the box. We're looking at ways to make it
easier to just insert those in places,
but since you have word keys that do that
already, you can just insert them in any
documents and Hyperbole will recognize them.
I think In some cases you may need to put ID
colon in front of the ID as well.
Generally it works.
[Speaker 1]: Ok, great. Moving on to the next question.
Regarding the frames example,
any thoughts or considerations for a
transient interface or is this something 1
could already toggle? Are you familiar with
transient interface?
[Speaker 0]: Yes, we don't use transient because we,
you know, Hyperbole started out in 1991,
though it's had much much work since then so
we predate a lot of newer things in Emacs and
then we just use them as as they Become
useful too hyperbole We think the The mini
buffer menu is pretty good.
We could rewrite stuff in transient,
but we haven't seen the need yet.
Maybe high control, that might be a good
candidate, because there are so many keys in
it. So we'll think about that.
But it would be a while before we got to it.
[Speaker 1]: Right. Moving on to the next question.
Sorry I got really confused because there's a
French salut, you know,
in the text of it. Is someone saying hi to me
or something? All right,
next question. Regarding multi-file search
functionality, why not implement it within
the existing framework of MetaX grep or
similar built-in commands?
Yet another search interface sounds a bit
redundant.
[Speaker 0]: Multi-file search, so HiRolo I guess you're
talking about. I think what you missed there
is that High Rollo matches to records,
multi-line records, so it's not a
line-oriented match, it's a record-oriented
match. So Grep, you can say maybe give me 3
lines of context, but what if I have a
20-line record? I want to see the whole
thing. And so, it's a full-text search
interface, which lets you have any size
entries or nodes in the match buffer.
So that's 1 reason. MADAX grep works with
hyperbole. I mean, you use it if you want and
then you can hit MADA return on grep lines.
So we basically take everything from POSIX
and everything in Emacs and we try to make a
lot of it simpler to use.
We don't take away any of the functionality,
we just augment it.
[Speaker 1]: Right, and I think that's the logic for a lot
of the packages, you know,
the philosophy is just you create your little
bit, your little island where you do your
stuff. And if you can resonate with other
islands so much the better.
And it feels like between those islands,
you know, hyperbole is a great way to connect
things that are just text.
So it's always been a lovely philosophy.
There's always been a lovely philosophy
behind it.
[Speaker 0]: 1 other point I'd make there is that the
Hyrolo also contains logical search
operators. So when I typed in that string you
could just as well type with like Lisp
expressions, semi Lisp expressions.
You can say open paren and word 1,
word 2, close paren. You know you can have or
and XOR and not and it'll do the search and
just retrieve the entries,
again, multi-line entries that match all of
the criteria that you specified there.
So that's fairly unique,
I think. So you basically got a full text
search platform with logical operators,
instantly, you know, fast moving,
rapid keys that you can control everything
with and it's all integrated into this larger
framework.
[Speaker 1]: Okay, great. Well, Bob,
you have 2 more questions,
but there's a big 1 about what inspired you
to write it back. It's being hyperbole around
the time of its birth,
but sadly, we only have about 1 more minute.
So what I'm going to ask you to do,
feel free to answer the question.
If you go on BBB, I've pasted the link to the
other pad. I think you can see it on your
[Speaker 0]: I have the ether pad up.
[Speaker 1]: computer as well. Right,
so what are we going to do?
I'm Sorry, I'm just a little bit pressed by
time because it's not me controlling when we
move on to the next talk,
as was evidenced yesterday when we got yonked
to the next talk. So Bob,
feel free to take all the time you want to
answer questions. People,
if you wanna join the Big Blue Button room,
the links are available and open on the talk
page. You can join and ask as many questions
as you want to Bob. And for us,
with a live stream, we'll be moving on to the
next talk in about 30 seconds.
So Bob, all that's left is for me to thank
you for your presentation again this year and
[Speaker 0]: Thank you, Leo.
[Speaker 1]: for all your answers. All right.
Bye bye, Bob. And we'll be moving on to the
next talk in about 10 seconds.
See you in a bit. All right,
Bob, we are off air I think now.
Thank you so much. I need to get moving for
[Speaker 0]: Okay, is somebody gonna keep writing answers
in here or I need to type them in?
[Speaker 1]: the next talk. It's probably best now if you
read the questions on your own and answer
them. We'll collate everything together,
we'd just like to have your answers.
[Speaker 0]: I hope some people will join the BBB.
[Speaker 1]: it in my... All right,
bye-bye.
[Speaker 0]: But I'll start. I'll put Bye-bye.
So let me take a second here to see what
questions we have. Did we cover that?
OK. The point is why not upstream search
interface? Could you clarify that question?
I don't quite know what that means.
So I'll go on to the next 1 and come back to
that. Hyperlinks been around for a number of
years now. What inspired you to write it back
around the time of its birth?
Well, that's a great question.
It was born before the World Wide Web,
actually. And it was right before.
I remember we were in the midst of a version
when the first version of the web occurred.
And I was thinking that there was going to be
an information explosion of unstructured
information. And like we needed to have much
better tools to be able to manage say like
5,000 email messages coming in and all sorts
of non-database-oriented information
structures. So I said we need an advanced
interactive hypertext system and it needs to
work with all the general capabilities that
we use like email and our document production
systems. So I was doing research at the time
at a university And I decided to work on
something that we called personalized
information environments.
And there's a paper about this out there if
you want to dig it out on the web.
So Pies, as they were called,
was an architecture which would have a bunch
of managers, like Hyperbole was 1 of the
managers, the hypertext manager,
and then a bunch of point tools that would
leverage the managers,
like an email reader would be a point tool
that would leverage the hypertext manager.
And so the first, I did in fact write
something called PyMail,
which was very much Gmail-like,
before Gmail. And so inside,
and I did a, it was like our mail in a way,
but inside your our mail summaries,
for example, you could have explicit buttons
embedded and that were drawn from the subject
of your email message,
and they'd work just like the regular button.
So it was very flexible,
and it had rule-based processing and things.
So Hyperbole came out of that,
and it's come a long way,
but it's still a very useful core hypertext
system, hypermedia system,
I should say. Are you familiar with the
Embark package? I am a bit.
I've just started using it.
I think there's some overlapping
functionality with hyperbole.
Yes, we've found that people over time have
enjoyed hyperbole and have started
replicating some of its features,
you know, small amounts of the features.
I talked to, I hope I don't miss his name,
but O'Adam who writes that once in a while we
dialogue and I think Embark is great,
you know, I'll give him some pointers too and
he thinks that Embark and hyperbole are quite
compatible too, just like organ hyperbole.
So that's how we like to keep it.
Some people prefer just a small package of
mBARC, and it does different things than what
Hyperbole does. So I think you use all of
these tools together, and they can work very
well together. Any other questions?
Anybody still here? If not,
probably people are off to another talk.
So thank you very much And again look for
Hyperbole version 9 in the next week.
Thanks very much. Bye.
Should I leave BBB? Oh Alpha Papa's here.
Hey. Good to see you. Alright,
well... Well, I'll stay for another minute,
but I think I'm going to go off video 2 and
start listening to another talk.
Thanks, everyone. Thanks everyone.
Yes, I can hear you. Yes,
[Speaker 1]: Have you been answering questions?
[Speaker 0]: I can hear you. finished answering the
questions. We're all done.
[Speaker 1]: I Okay, cool. Well, what I'm going to do,
I'm going to close the room unless you want
to go a little longer,
because this talk that we're playing right
now is finishing really quick and we don't
have a Q&A afterwards.
So, do you want to stay on air or something?
[Speaker 0]: Yeah, if you let people know to come back,
because someone went to go hear that
presentation, I can stay.
[Speaker 1]: Sure, I'll make an announcement then.
And you can stay, we'll just put on BBB.
You can stay muted until people join,
but this way it opens up menus for people to
join and if no 1 shows up in 5 minutes we'll
all go on break. Does that sound okay?
[Speaker 0]: Great, thank you.
[Speaker 1]: Cool, I'll go back to the management in the
background and I'll let you know.
Okay, Bob, I've won the stream.
We are joining it now.
We've got about 5 seconds.
And I think we are back.
so we are gone, Bob, please.
[Speaker 0]: Hi. So, yeah, I was going to say,
can we see if anybody comes back in the room?
How do you tell?
[Speaker 1]: You should be able to show on the left,
you've got on BbBlueButton,
you've got a button, I'm showing it on the
screen, but you've got a little button that
allows you to show the people joining.
So, hello everyone. Let's see if you had more
question on your pad that we could be taking
in the meantime, just give me a second to
find
[Speaker 0]: your pad. Here we go, an error occurred.
[Speaker 1]: All right, it's loading up.
[Speaker 0]: Okay. Wow. Feels like there's an AI writing
this stuff on the pad.
Has it? Is this the last pad?
Oh no, this is a different 1,
[Speaker 1]: Which question are you looking at now?
[Speaker 0]: sorry. It was a different pad,
[Speaker 1]: Oh right.
[Speaker 0]: that was the problem. Okay,
here we go. Okay, I'm back.
So, yeah, it looks like...
Is anybody back? Send,
if you're here, send a chat message.
[Speaker 1]: Yeah, because it's been something.
You have, apparently, whenever we leave those
BBB chat room open, the moment we go off air,
people start joining and asking a lot of very
interesting questions and you know that's all
well and good, we'll be able to put them on
the page later on. But it'd be great if you
could also have those discussions when we are
live because a lot of people would benefit
from the brilliance that goes on in this
room. So please don't be shy,
[Speaker 0]: So we're on the general stream now?
[Speaker 1]: join and talk. Yep, we are back on the
general stream. We have about until 10 of the
next hour, which is 19 minutes.
[Speaker 0]: Just- Why don't you and I talk?
So have you ever tried hyperbole,
Leo?
[Speaker 1]: I have never, but You know,
it feels like every year when you present
something, it feels like I already know so
much. Because of the buttons,
it feels like it's also something that we've
reinvented many times in Emacs.
It's like conversion to evolution,
except you're the 1 who started ahead of
everyone else.
[Speaker 0]: Well, that's a good point because,
you know, we have, Emacs itself has push
buttons, which you see like in the help
buffers. And those used to,
we didn't really do anything with those,
but now we've subsumed them as implicit
buttons as well. So you're made a return,
we'll work on those anywhere too.
So, we're trying to get,
you use 1 key, right? To control every type
of button that you have.
It works on org links,
org buttons anywhere, or URLs.
Because it's so simple.
All you need is like 5 to 10 lines of code to
map. You map the pattern that represents a
concept, right? And then you can create an
infinite number of those buttons from that
type. That's what's really cool about
Hyperbole, is say I have a 500 page document
and it uses a really weird format for
cross-referencing, right?
I write my 3 lines of pattern match to work
with that. And then everywhere throughout
that document and the hundreds of other
documents that will be created with that
format, they're all live buttons instantly.
Nothing changed about the document.
That's really cool. You know,
word mode, we have global word buttons,
but mostly it has to be embedded within an
org file, right? And follow that syntax.
With hyperbole, it's like we can adapt as the
world adapts around us to whatever formats
people want to use that day.
And you can even change things to look the
way you want, right, and have your own
cross-references. There's something built
into Hyperbole that's not really active,
which was sort of along the Zettelkasten way.
We wrote this a long time ago.
It's called hib-doc.el,
and it's a card catalog notion.
So it uses the high rollo in the background
but it lets you create these forms that are
cards that you fill out with whatever kind of
data you want and then it gives you the full
text searching across the cards and each card
has a unique ID that you can reference
similar to org IDs but these are human
readable and human typable and so you can you
can just have a cross-reference to any doc ID
and essentially create what Engelbart used to
call a journal, which is all these IDs on
documents that point you directly to the
document archive so that you could have like
your internal publishing system and you know
it's very simple to do and it's just 1 module
added on to Hyperbole.
[Speaker 1]: Yeah it's especially interesting for me you
know because coming back to the side of
convergent evolutions it's funny because the
parameters are a little different.
For us with org buttons,
we're very happy. A lot of the stuff during
EmacsConf is run with org mode,
like we have Elisp going everywhere to
compile a lot of org properties,
like speaker information,
for instance, how long the talk is,
the title, and all this.
We have all of this in an org file,
which we use as a database,
but then we can do so much stuff.
We can send email and we can update the
schedule. By the way, if you're interested in
this, we'll have a talk on the DevTrack in
the afternoon today that Sacha did and it's
wonderful. I'm just teasing it.
[Speaker 0]: Oh, that's great.
[Speaker 1]: But coming back to Hyperbole,
for you, it feels like the parameters were
slightly different because the feeling was,
I just want a tunnel that can work between
any type of files. Now,
it's all well and good.
Org-Rome, D-Note, and all the stuff like
this, they create bidirectional links.
But it's only between org-mode files.
Whereas what you're achieving with Hyperbole,
and you've done it much earlier than everyone
else, is that you have this concept
regardless of the type of file that you're
using. And I find this to be beautiful.
Like 5 years ago, whenever you were talking
about hyperbole, I did not have a concrete
idea of what was happening.
But ever since I've gone through the journey
of really understanding what the El Caster
method were about, it feels like you were
foreigners in the topic.
Obviously, you've mentioned the mother of all
demos by Edward Engelbart,
but those ideas are not novel,
but it feels like only now are they starting
to be appropriated by people,
especially in free software,
and it's really good to see.
I'm really excited to,
well, have my small part to play in this.
And I'm also excited to be able to chat with
you and people like Bastien and other people
about all those topics.
[Speaker 0]: Yeah, I think, you know,
it's fun that we can laugh now about when
people say people are still using Emacs,
you know, is because they're not used,
certain people aren't using it.
They have no idea of how far it's come and
how powerful it is. And,
you know, we're leveraging Elisp heavily,
obviously, but if you look at the definition
of our types, they look exactly like DIP
funds in ELisp. And we've been able to do
that because of Lisp macros.
You know, we so we basically have our own
domain specific language there,
but there's almost nothing to learn because
it's just like what you know from UList.
So again, you know, taking the concept and
leveraging it, abstracting it and leveraging
it multiple times gives you a lot of power.
And people, you know, somebody said the other
day, and I said, finally,
this quote happened. He said,
there's so many things that I do with
hyperbole every day that I forget that I'm
using hyperbole. Because it's just so
embedded in this guy's workflow.
And that's really how I use it.
You know, there are features in there,
can't use everything, right?
So there are features that I don't use,
but I use a lot of things and it's all like
muscle memory, just like the keyboard,
the Emacs key bindings.
So it's very exciting to get to that level.
And now, you know, we haven't started with
the chatbots or any of the AI integration,
but I'm starting to think about that a little
bit and how we'll interface to that world and
I think it's going to be very exciting.
[Speaker 1]: Yeah, likewise and I think it harks back to
what we were talking about before when we
mentioned Hyperbole being a package inside of
an ecosystem that is Emacs.
But it's not because something is well
circumscribed in terms of feature set that it
does not influence everything around it.
Like Hyperbole can be used with something
completely at the opposite end of what it was
intended for, just because it provides a good
set of tools that can be used wherever else
you want in Emacs. And it's the same thing
with Org Mode, it's the same thing with many,
many different things.
And it feels like integrating AIs,
or generative AIs, into Emacs would provide
such a tool that could apply to any kind of
other major mode or any kind of other use.
So I'm also excited to see this.
It feels like we are sitting at the brink of
a revolution. I'm not going to say the acne
stuff, but it definitely feels like right
now, by trying to see what we can do with AI,
it's definitely going to change the way not
only we program, but also the way we take
notes and the way we design stuff,
arcing back to what John Wigley said
yesterday about his draft program on macOS.
Bob, if you don't mind,
I see people typing questions and I also see
people joining on people buttons,
so I'm going to read you the 2 questions that
have been added. Is that okay?
[Speaker 0]: Great, go for it.
[Speaker 1]: Cool, so first question.
Wow, what you're describing now,
and that's when you were talking about the
bi-directional links and especially the last
question in its entirety,
What you're describing now reminds me a lot
about HyperCard that I grew up on.
Do you know if Hyperbole inspired Bill
Atkinson or if you were inspired by
HyperCard? Or were there just a lot of
thoughts about hyper-contextuality around
that time?
[Speaker 0]: Alright, well this is another interesting
anecdote. I don't know if it's true or not,
but I think HyperCard predated our stuff.
It was right around the same time when
Hyperbole was starting out.
But when I was doing the Pi research,
I worked at, when I left school,
I worked at Motorola, and we did a lot of
work with Apple back then.
And somebody came back and he said,
you know, the people over there have seen
your Pi research and they really liked it a
lot. And so they were leveraging that when
they decided to create the division that they
called Apple Pi, which was the originator of
the Newton which eventually led to the
iPhone. So it all kind of is interconnected
just like the impact that free software has
had around the world. So you never know where
your stuff is gonna go or end up.
[Speaker 1]: Right. All right, moving on to the next
question. Is it possible to only use 1
feature of hyperbole without the others,
i.e. Using only the implicit explicit buttons
without I control I roller or without having
to rewrite part of the code in hyperbole in
order to be able to load a smaller hyperbole.
Does it make sense?
[Speaker 0]: Yes we get asked this all the time.
So you can use any little bit that you want
anywhere right you can even just call code
from Hyperbole. I mean you don't use
everything in Emacs, right?
But you still install Emacs on your machine.
It's exactly the same thing.
Those libraries don't take up any memory,
they take up a little disk space and it's so
trivial compared to the amount of disk we
have today. So a lot of things are not loaded
unless you activate them.
And so I know that you do have to build all
those things. So maybe that's what bothers
people. It takes 2 minutes if you're using,
it depends how fast your computer is.
But you build it once on install like every
other package. And it used to be that there
would be a lot of warnings just because of
the way we wrote the code and we didn't
really have to deal with some of those
warnings. But with this new release,
we've gotten rid of almost all of them,
including the native compiler messages.
So it should be a very clean install now,
and just use 1 part at a time.
But the other parts are there in case you
make a link to something and you use a
facility just like I was showing as I went
across subsystems today.
It may take you a year,
but then all of a sudden you find the use
case for Hyrule and you say,
oh, I'm glad I have it there.
And yes, some of these things could be split
into sub packages like you do in the org
ecosystem. But given our limited resources on
the team, we find having them all in 1 gives
us a higher level of quality and lets us
deliver a better integrated system for your
use.
[Speaker 1]: Yeah, exactly. And I think,
you know, it's, it's not a monolith.
I mean, it's usually easier,
easy, more easy, more easy.
Sorry, I was right on the first try.
It's usually easier to maintain a monolith
that contains many bits of functionality like
org. You have plenty of people using org
mode, not using org-agenda,
for instance, or you've got plenty of people
using org-mode and barely using Babel because
it doesn't really translate to their use.
And I feel like I very much agree with you.
It's okay to install a package and only use
some of the functions.
I was reminded, as you were discussing this,
of the consults package,
which is part of the VertiCo,
mbark and marginalia and all this.
Consult, it replaces a lot of the Emacs
built-in commands like for finding your
buffers or finding text inside of your
buffer. It's great. And you do not need to
completely move to consult as you get
started. You can start colonizing 1 step at a
time the function that you usually use.
And I highly recommend to people to not let
the size of a project deter them from trying
it out because, again,
in Emacs, everything is horizontal.
If somehow you want to use something that was
not intended primarily for this,
or if you only want to use 10% of a package,
well, do it. An example that I have for me is
that Lispy is the minor mode that I use for
editing Elisp documents,
and it's great. Elisp provides similar
functions to ParaEdit,
which might be a little more popular,
which allows you to have modal editing when
you are on specific parts of a file,
like the opening parenthesis or the closing
parenthesis. It's great,
it provides modal editing for those modes,
but I certainly do not know everything,
every modal command associated to it.
I just use the 1 that makes the most sense to
me. So feel free to explore.
[Speaker 0]: I'll just say we get this so much.
It's not that large. I mean there's a fair
number of files but it's just like 1 major
directory and then the KOutliner directory.
And when you look at these things,
you install web applications,
everything else, just when you download the
source code, it's much,
much smaller than any of that.
So I don't know why people you know accept
that it's larger than your typical package.
Why there's really an issue there.
[Speaker 1]: I think it's because people tend to assume
that a paradigm like the 1 you're describing,
which seems to be changing the way you use
Emacs in a way because you're no longer
thinking of as buffers as separate entities,
you can tunnel between them.
You know, it feels like a huge paradigm shift
and you assume that the code behind it is
going to be humongous as well,
but it's usually not the case.
It's just that the idea is very pure at the
start, and the paradigm shift that it allows
is also magnificent. But at the end of the
day, the code is fairly simple,
because it does 1 thing and it does it well.
[Speaker 0]: 1 thing I noticed too,
I mean I'm a big believer in turnkey kind of
systems. In fact a long time ago when I built
an IDE on Emacs called InfoDoc that was
delivered pre-compiled.
So it's like you download it like every other
app and you run it. And so I think
eliminating all the friction that occurs,
and you know, I just got going recently with
the wonderful packages that you just
mentioned, VertiCo and Consult,
but they don't have a manual that covers all
that. They use sort of like a cookbook,
a wiki online to answer a lot of the
questions that people have and everybody has
to figure out their configurations you know
to make these things all work together.
We'd like to do that engineering and say here
it is you know it's like if you want to
configure it and make it your own,
you can do it. But there is a default
configuration that handles all the typical
use cases and you can just load it up and run
because it's made to use,
you don't have to hack it to make it useful
for you.
[Speaker 1]: Yeah, it reminds me of the discussion we had
with Stéphane yesterday about sane defaults.
And I think the question was,
Emacs should probably ship with sane defaults
for people. And Stéphane's answer was,
well, my sane defaults might not be the same
thing as your sane defaults.
And that's why I think it's important,
really, to have a core set of features,
be it with hyperbole of org mode,
that is well-documented,
as you mentioned. But what I like about this
in a way, and I think hyperbole is perhaps
taking more benefits of this than Org Mode,
is that the self-documentation aspect of it
feels like it's easier with hyperbole because
you're not bound by Org Mode buffers.
You can link to just about everything.
And for me, this ability to self-document is,
well, first, very true to the philosophy of
Emacs in the first place,
but also opens up those resonance cycles
where, oh, you get interested and then you
start reading up and then the documentation
is so good that it feeds into your practice
and then it goes nuclear and you gain so much
knowledge as a result of this.
All right, Bob, we are about out of time.
We only have about 1 minute until we go to
the next talk. Do you have any passing words?
[Speaker 0]: I do. I think, you know,
the world's complex, it's getting more
complex. I think that's why people use Emacs
in the first place, because it's a big
system. You wouldn't use it unless you wanted
it to simplify your life.
Hyperbole is built with the same idea in
mind. You may not get it just like Lisp.
A lot of people don't understand when they
first encounter it, but when they do
understand it, they're blown away.
It changes their life.
You know, when you really understand implicit
buttons, I think that's 1 of the things in
hyperbole that can change your Emacs working
life. So just give that a try and I think
you'll be pleasantly surprised across time.
[Speaker 1]: you so much Bob. We'll be moving on to the
next talk in about 20 seconds so everyone see
you in a bit and Bob thank you so much again.
[Speaker 0]: Thanks very much. And thank Thank you.
[Speaker 1]: All right I think we are off here now.
So thank you so much, Bob.
I'm going to need to step out and get ready
[Speaker 0]: Yeah, do your thing. You do a great job at
it. But I wanted to ask you where in London
[Speaker 1]: for the next talk. I'm not in London,
I'm in France, and I just moved to London.
[Speaker 0]: you are. Oh, okay, got it.
Sorry, I thought you were.
Take care.
[Speaker 1]: All right, bye-bye, Bob.
Thanks a lot. Bye-bye.
Bye-bye.