Hi! My name is Eduardo Ochs.
I'm this person here,
and the title of this talk is:
"On why most of the best features
in eev look like 5-minute hacks".
And this is a presentation at the
EmacsConf 20202,
happening in november 28 and 29.
2020.
So this is part one of the presentation,
and here I'm going to explain some
ideas that are prerequisites for
understanding the rest of the
presentation.
The three main keys of eev are `M-e',
`M-k' and `M-j', and I'm going to start by
explaining `M-e' and `M-k'.
`M-e' is used to follow a hyperlink, and
technically it is
essentially just a `C-e' to move to the
end of the line and then a `C-x C-e'
to execute the sexp before point
at the end of the line...
and the thing is that Emacs comes with
many functions that can be used as sexp
hyperlinks.
We can consider that they "point" to
somewhere. I'm going to refer to that as
the "target" of the hyperlink, and if we
execute these sexp hyperlinks we
"go to" that target.
For example, this one
is a hyperlink that points to a buffer
with the man page for cat,
and usually, but not always, after
following the hyperlink
we can go back by just killing the
current buffer...
that the hyperlink created -
the "target" of the hyperlink.
But this example here is badly
behaved.
If we execute it it creates a new frame,
and to go back to the previous situation
we have to either
click here or type `C-x 5 0'.
So, here are some examples of sexp
hyperlinks using standard Emacs functions.
This third one is badly behaved in a
different way.
If we executed it the target is created
in the same window
as we are now, but it also shows a lot of
garbage here in the echo area, so
the current frame becomes a bit
messy...
and, well, one of the first things that I
did when I was creating eev
many many years ago was that I created
variants
of all these functions that were better
behaved...
and they were better behaved in two
senses: the obvious one
was that they all created the target
in the same window as before, so I could
go back by just typing `M-k',
which essentially just killed this
buffer...
But I also implemented
something extra, that are the
"pos-spec-lists"... for example,
these extra arguments here
are a pos-spec-list,
and these extra arguments specify
a position in the target buffer.
And in this example this pos-spec-list
means: starting from the
beginning of the buffer,
search for the first occurrence of this
string, "C-x C-e", after that -
after the beginning of the buffer -
and then search for the first occurrence
of this string, "eval-last-sexp",
after that.
Eev also defines some hyperlinks that do
not create new buffers.
Here is the first example: if I execute
this one... this one is a hyperlink to the
result of running this shell command,
"date"...
but instead of showing the result in a
new buffer the result is shown here...
so if execute this hyperlink the result
of "date"... the output of "date" is
shown in the echo area, and if I execute
it again
it shows the result again, and the result
changes every second.
So this is a variant of `find-sh'...
`find-sh0' is the variant that
just shows the output in the echo area,
and `find-sh' shows the output in
a new buffer.
And here is an example of a hyperlink
that calls an external program.
If I execute this it
calls Google Chrome to open a
certain URL.
Here it is. Let's go back to Emacs...
if execute this hyperlink here
it invokes my favorite PDF viewer, which
is xpdf... it makes xpdf
open this PDF in this page...
and these other arguments are ignored.
Let me show how it works.
Here it is. This is an excerpt from a
book... so page 3 in the PDF corresponds
to page 113 in the book... and
this variant here of the hyperlink above...
it opens the PDF in a different way.
It runs a program called pdftotext on
this PDF here,
and Emacs takes the output of running
pdftotext on this PDF here,
and displays it in a buffer... and now this
pos-spec-list is interpreted in a different
way: this thing is interpreted as a
number of a page... Emacs goes to page 3
by counting formfeeds in the
converted version of the PDF,
and then it searches for this string
and this string.
So let's execute this to see what
happens... here it is. It opened
the same page as before...
it starts with "Lecture I", so
the other hyperlink searched for this
string and for this string here.
And this thing here is a hyperlink to
a video.
When I executed it it is going to open
this video here, at this timestamp.
Let's see... one, two, three...
ONE, TWO, THREE! THAT'S THE WAY TO DO IT!
And also some hyperlinks that I
defined... hm,
they don't work like usual hyperlinks,
they work more like browser buttons,
these buttons that appear in web pages...
In the sense that these buttons usually
don't open a new page, they usually
just do something to change the current
page. If I execute this,
the action of this function, `eek' is to...
it interprets this string as a series of
keys, and it acts as if the user had typed
all these keys, so...
if I executed it I get a "HELLO!"
in the next line, and if I execute it
again I get another "HELLO!"
another "HELLO!", another "HELLO!", etc...
Let me undo this mess.
And here is another kind of button,
that defines a new function. If I execute
this sexp here, `(o)'...
at this moment the `o' is not defined,
and if i execute this Emacs is going to
show me a message saying
"Symbol's function cell is not defined",
something like this...
but if I execute the `defun',
the action of this function `o' here
is to run this, which opens a certain
directory...
let me go back. And here is another
button that defines
several functions at the same time.
If I execute this...
note that the result of executing
this expression, (code-c-d ...),
is the name of one of the functions that
it defined,
that is this one here, and let me explain
these examples. One of the functions
that this thing here defined
is called `find-orggitfile', where
this "orggit" in the middle of its name
is exactly this first argument
to `code-c-d'...
and the action of running
`find-orggitfile' on a string like this
is that `find-orggitfile' takes this string
and prepends this string to it...
this one here, which is the second
argument to `code-c-d'...
and then it executes `find-fline'
on the result, which is this one...
and `find-fline' is my variant of
`find-file' that supports pos-spec-lists.
And this function here, that I'm
referring to as a "button", it also
defines a function called
`find-orggitnode' here, where the "orggit"
is the same string as here,
and this function opens a node
of an info manual. This sexp here
opens this node in the Org manual...
it is equivalent to this sexp here...
so in the passage from this line to this
line we prepended to the node name
the name of the manual - here...
and `find-node' is my variant of this
standard Emacs function here, `info',
but `find-node' also supports
pos-spec-lists.
Eev also defines some functions that
define shorter hyperlinks to PDFs and
videos.
Remember that this thing here is a
shorter hyperlink to a
to a file, and this thing here is a
shorter hyperlink to a node in an
Emacs manual... in an info manual.
If we run this thing here - this
`code-pdf-page'
this acts like a button that defines a
certain function,
and this other sexp here
defines another function. The first
one defines the function
`find-fongspivakpage', and
the second one defines the function
`find-fongspivaktext'. When we run
`find-fongspivaktext' it opens
this pdf here... the name is
quite long...
this example opens this pdf at page 8
and searches for the string "Contents".
Oops, sorry, in this case
it just ignores this string
here, it only considers
the number of the page. Let's try.
Aaaah!
Here it is. The contents of a book
that is freely available...
here is another page of the book...
and if we execute this hyperlink here,
`find-fongspivaktext', it converts the
PDF to text and it searches
for the page 8 in it, and then
for the string... this
string here in page 8.
It takes a few seconds...
here it is. So this is the
ascii version of this "Contents" page
here. Note that this block here
is a kind of an index to that book...
I have the full index somewhere, but
it's very long, so I just copied a few
lines here...
so this is a link to the
Section 1, oops, Chapter 1...
this is the section 1.1,
section 1.1.1, and so on...
and here is a link to the index,
And here is a part of my index
of positions in the video that we just
saw that i think that are especially
relevant.
So this
hyperlink is a kind of a button that
defines this function here,
`find-punchandjudyvideo'... let's try.
And we can also use this for video
tutorials. For example,
this is a very good tutorial on magit.
if we execute this
then these functions are going to be
defined, and these functions open
this tutorial on magit, and
these are some of the positions in the
tutorial that I found especially
relevant. This is a very dense
tutorial, I had to take notes of
everything,
and I had to watch everything
several times...
and for example, this is a link to the
position in the tutorial that explains
how in Spacemacs magit
interprets `SPC g s' as `magit-status'.
let's see...
and here are some examples that I
took from somewhere else... the video
tutorials from
Ralph Koenig about Org mode.
Now let me show how the functions that
define these shorter hyperlinks are
implemented.
The standard way in Emacs to define
functions that define
other functions would be with macros.
Let's see an example. This is a standard
function that
defines new functions...
and if we execute it
its result is the last function that it
defined, which is `ee-glyph',
which is here...
it's implemented as a macro, we can
look at the result of `macro-expand',
which is going to show us the result
of the expansion of this...
instead of expanding and executing it
expands and shows us the result.
Here - the result is a bit messy,
it is too big for
humans to understand, but we can run
this other sexp here, that takes that
result and pretty-prints it.
So this is the pretty-printed version of
this macro here.
We can see that it defines
several functions here...
For example, this one...
and this, just as a curiosity, is a link
to the definition of `cl-defstruct'...
and note that the code is huge...
well, it's very well commented,
but it has lots of special cases,
it supports lots of constructions...
and so it's huge and it's very difficult
to understand. I mean,
I found it very difficult to understand.
And here's a link to the documentation
of `cl-defstruct'...
here in the manual for `cl',
which is a kind of support for some
features of Common Lisp in Emacs.
So let's compare this standard way of
defining
functions that define new functions,
which is with macros...
with this. I'm going to use a slogan
repeatedly - the slogan is
"I am a very bad programmer".
I'm a very bad programmer, so when i was
trying to create functions that would
define new functions
I found it easier to generate
Lisp code as text
and then run `read' and `eval' in it.
The `code-c-d' that we saw in the
previous section
we can see the the code that it produces
by making a copy of this line and
prepending this string here, "find-",
to the name of the function...
so instead of running `code-c-d' we run
`find-code-c-d',
and it creates a new temporary buffer
with the code that
`code-c-d' would execute.
So it's a series of `defun's and a few
`setq's... and this thing is implemented
mostly as a template. The low-level...
there's an inner function called
`ee-code-c-d-base' that receives just
these two arguments, and it essentially
just runs the function `ee-template0'
on this string here, and
the things between curly braces are
substituted by the values
of these arguments - here.
There's one part of the tutorial - here -
that explains all these things,
except for the rationale for some
design decisions...
and those design decisions are one of
the many motivations for this talk,
but I'm only going to explain these
things in detail at the end -
which is kind of soon. =)
In the beginning I said that the three
main keys of eev
are `M-e', `M-k' and `M-j'...
let's see now what `M-j' does.
But I need to start with some
motivation.
The motivation is that we can define
commands with very short names, and
actually I became kind of addicted to
that...
this is an example of `defun' that
defines a command with a very short name.
Its name is just one letter, `e',
and I can invoke it with `M-x e'.
If I type `M-x e' now
it opens a LaTeX file that I'm
working on,
and I create most of my LaTeX files
using template-based functions, like
the implementation of `code-c-d' above...
and these template-based functions create
files with the extension .tex
that start with a series of `defun's
in comments. For example...
Let's look at this example here. If I
execute `find-latex-links' with this
argument, it's going to do several
things for creating a file called
"/tmp/foo.tex"...
and the header of that file is going to
be this, which starts with three `defun's
with functions with very short
names in comments.
Let's compare with the situation here...
in my file "2020favorite-conventions.tex"
I have this header here, in which I
define six functions with very short
names...
and in this case here, that is even
explained in the tutorial...
we have mnemonics for these short names here:
`c' is "compile", `d' is "display",
I mean, display the PDF...
and `e' is "edit", in the sense of:
make Emacs visit that file.
Okay, now I can explain what is `M-j'
itself. We just saw command with
very short _names_, and the idea
behind `M-j' is that we
can define commands with very short
_numbers_.
Let me explain this.
The short explanation for what `M-j' does
is that it jumps to certain
predefined places...
in particular a `M-j' without a numeric
argument takes us to a buffer with
the basic help and the list of
the current eejump targets...
and this is something that is a bit
simpler to understand:
if we type `M-5 M-j' then `M-j' runs
this sexp here, (find-eev-quick-intro),
that is associated to
the argument 5... I say that the target
for the argument 5 is this one.
And if the argument is 2 then the
target associated to the 2 is this
sexp here, that opens...
well, this one opens the main tutorial of
eev, and this one opens another tutorial.
This is a link to one of the tutorials
of eev, to the part that explains `M-j'...
I've copied the the main part of the
text here.
The header - the header that `M-j' shows;
let me show it very quickly...
here is the header and here is the rest -
the header is very beginner friendly, and
if you're a beginner who only knows how to
`M-e' to execute and `M-k' to go back,
then you can, and should, use that header...
I mean this header here -
as your main starting point, and every
time that you feel lost
you can type `M-j' and to go back to
that header...
and you can use its links to navigate to
the documentation for Emacs and eev.
Let me explain that.
This header here has several elisp
hyperlinks...
one here, one here,
one here, one here, and so on...
these ones are links to the "intro"s,
which are the tutorials...
(find-eev-quick-intro) is the main
tutorial, and (find-eev-keys-intro)
is a kind of tutorial that is
an index of the main keys...
and after that we have an explanation of
what some numeric prefixes do...
so if we type `M-1 M-j' the effect of that
is exactly the same as executing this,
and we can execute this with `M-e' also.
`M-2 M-j' runs this sexp,
I can also execute it with `M-e'...
here it is, it's this intro, this
sandboxed tutorial... and
here is another sandboxed tutorial.
Let me go back... and then the
documentation says that that header -
the header that is beginner-friendly -
is followed by a section that is very
beginner UN-friendly,
that contains a series of `defun's like
these ones, here...
the last line of the header is this
comment here, and then we have
several `defun's like this.
Let me explain how these things work.
Technically, what happens when we type
`M-j' without any arguments is that it
runs `eejump' with the argument nil,
and then this runs `find-eejumps'.
When I run `M-j' with a numeric
argument, for example
with argument 5, it runs (eejump 5),
and (eejump 5) concatenates this 5
to make a name of a function - this
function here...
and it executes this function,
`eejump-5'... and (eejump-5)
executes (find-eev-quick-intro).
If I execute just `M-j'
this section that shows the current
eejump targets
has a line for eejump-5, this is
exactly the thing that I was explaining
before. So we can use `M-j' to navigate
the tutorials, and we can copy
links to the tutorials to our notes...
oh, sorry this has some typos...
for example, if I execute this
I go to a section of this tutorial here
that explains the main keys of eev,
and these things are hyperlinks... I can
mark a hyperlink like this, it is just
plain text, and I can copy it to my notes...
and the idea is that every time
that I find something that is
interesting I can create a hyperlink to
it, and i can put these links in my notes,
so I can navigate back
to all the interesting positions
very quickly.
Ok, next feature; if we type
`M-J' (meta-uppercase-j), then...
this is a function that transforms the
current line in a certain way.
Let me give an example. Let me isolate
this, and let me duplicate
this line to make clear what happens.
If I type `M-J' here
this line here becomes a `defun' for
`ee-jump6', and the target of this
eejump is exactly this sexp here.
Let me undo this mess.
And if the first word in the line is not
a number - for example, here...
let me do the same thing,
duplicate the line and type `M-J'...
then `M-J' converts that to a defun
that defines a function with a very
short name,
and this function with a very short name
opens this file here, in the directory
with the copy of the the git repository
for Org mode.
Let me undo the mess again.
`M-J' is a particular case
of something that I use a lot in eev.
Eev has lots of key sequences
that are like meta-uppercaseletter, and
almost all of them operate on the
current line, and transform the current
line in a certain way.
For example, this is a file name,
and if I type `M-F' here
it becomes a link to that file...
this is the name of a manpage,
and if I type `M-M' here
it converts that to a link to a manpage,
and this is a shell command,
and if i type `M-S' here
it converts that to a link to a
to `find-sh'...
and until a few years ago these
functions with meta-uppercaseletter
were half of my main ways
of creating sexps
with few key strokes. In the beginning, of
course, I had to create my
sexp hyperlinks by typing each character,
but after some time I decided that
i needed something more efficient.
So this is the end of Part 1 of the
presentation.
So, this is Part 2 of the presentation,
and the main theme here
is the standard `describe-key'
function that comes with Emacs,
and my variant of it. The thing is that
the standard `describe-key' in Emacs
is user friendly but it is
hacker-unfriendly... well, I felt so,
and when I tried to complement it by
writing a hacker-friendly version of it
that produced the sexp hyperlinks that I
needed I got something that I found really
lovely, and
several of the main designs decisions
of eev can be seen there...
but when I showed my variants to other
people they hated it -
they felt that it was totally against
their notions of
user-friendliness.
Ok, so let's see the standard
`describe-key'. If I run
this hyperlink here I get
the result of running `describe-key'
on the key <down>...
and this is a big buffer with some
things in italics,
and some hyperlinks - here. These
hyperlinks are standard, in the sense that
their targets are not visible and they are
implemented using buttons in Emacs Lisp.
This section of the Emacs manual describes
how buttons work,
and the the source code is
quite difficult... I mean, when I was
starting to try to decipher this,
when I was a beginner using Emacs 19.34
I felt that this `describe-key' was
very difficult to understand,
and I felt that the the people who wrote it
were sacrificing too much of the
hacker-friendliness that I was expecting
from it to make it beginner-friendly.
Let me explain what are the the problems
with the standard `describe-key'.
If we think that hyperlinks
are things like this,
with the TARGET and the TEXT, then in the
button-hyperlinks of `describe-key'
these three bad things happen. First;
it is hard to extract the target from
the hyperlink. Second: it is hard to
recreate Lisp code that would go to that
target, and third: it is hard to copy the
full hyperlink, including the target,
to other buffers -
I already knew how to copy the text.
When I was trying to decipher what
`describe-key' was doing
I created lots of hyperlinks like this
to inspect the text properties and
things like that...
for example, in the description of the
key <down>, here...
we have a button that points to
simple.el...
the text of that button is "simple.el",
this hyperlink goes to the middle of this
button-hyperlink here,
this hyperlink here goes to the middle
of this button-hyperlink and then inspects
its text properties, and then goes to
this section here of the description...
so this is a high-level description of
the text properties... I mean,
the text properties that make it
a button... and this is a
lower-level description of these text
properties.
And the button whose text
is "forward line", this one,
is slightly different...
this hyperlink here goes to the middle
of that button,
and this hyperlink goes to the middle
of that button, inspects its
text properties, and goes to
the section of this help,
uh, buffer, here that describe the the
button and the lower-level view
of the text properties.
So, I started with things like these to
understand what these buttons were doing,
and I was able to figure out how these
things are implemented, and `describe-key',
and similar help functions in Emacs...
and I discovered that one of the main
lower-level functions that Emacs used
for this is a function called
`find-function-noselect'...
if I run `find-function-noselect' on
'next-line, it returns a pair...
a cons made of a buffer and a position.
So I created functions that would
follow this, that would open that buffer
in that position, and then this is a
pos-spec-list...
so we could go to these positions and
then search for this string, and another
string, and another string, and so on...
so this goes to the definition of
`function-efunction' and then to a
string after it, and I use these things to
implement my own functions
that pointed to the same targets as the
button hyperlinks of `describe-key'...
Again, let me show the comparison...
this is the standard `describe-key' here,
and this is my variant...
it creates a buffer with elisp hyperlinks
about this key.
We get this, so each one of these
functions is either a blank line
or an elisp hyperlink...
here is a slight variant of the function
`find-ekey-links' above. In this variant
the argument is a string that has to be
processed by `read-kbd-macro' to convert it
to the lower-level format...
and note that these functions here that
I wrote...
they display temporary buffers with no
help at all.
To be honest there's a link to a
tutorial here, but
this is a recent addition, so let's ignore
this...
they display temporary buffers
with no help at all, just lots of
hyperlinks,
and these hyperlinks can be... they are
very hacker friendly, in the sense that
they can be followed with
`M-e', they can be copied to other
buffers, because they are plain text,
because they are just sexps...
and they can be inspected, in the sense
that... for example, here
we have a hyperlink to a function that
it may be difficult to figure out what
this function does...
but we can go to that position and then
type `C-h f' to see the
description of this function...
and here is a hyperlink that does that
in my syntax, say.
And these lists of hyperlinks were
generated by this code here,
that just uses backquote to generate
lists of sexps.
And I felt that this function here,
that just generated this list
was very easy to understand and to
modify, so this was hacker-friendly
in the way that I wanted.
And so I started using this...
and this idea of using buffers with
sexp hyperlinks and no help violated
all the notions of user-friendliness
that I knew, so I was
exploring something new at that time.
And this is the end of Part 2.
Part 3 of this presentation is
about the killer features of eev, or:
Why everybody should use eev, or at least
have eev installed, even if they think
that eev is too weird.
So: this is a very quick listing.
3.1. Eev has elisp hyperlinks, which are
super nice;
3.2. It comes with lots of tutorials.
The main one, here, explains all the
main features...
there's also a tutorial that is
an index of
all the other tutorials, here...
many, many, many tutorials.
If we forget everything we can
just type `M-j', and remember that
this this part here is
beginner-friendly and the rest is
beginner-unfriendly;
there's a tutorial on Emacs Lisp, here...
it mainly explains how to understand
elisp code, which is much easier than...
it's much easier to understand elisp code
then to understand how to program elisp,
and most people are only going to need
this.
3.3. Eev is very easy to install.
It's in ELPA, so we just need to do
this thing here, and it's very
non-invasive...
several years ago it was a very invasive
package, but then I changed everything.
Now if we toggle eev-mode on and off
what's going to happen is just that the
eev key map becomes activated or
deactivated, and when we
(require 'eev-load) the only things that
happen globally are these things here:
several functions and variables become
defined - all of them have
standard prefixes, except for one;
three characters are changed in the
standard display table to make them
appear as colored glyphs:
the red star and
tha open double angle brackets and
the closed double angle brackets;
and two environment variables are set.
and this is a trivial technicality...
we just run a `defadvice'
around one function that is used by man.
Just this.
3.4. Also, eev has a
very high discoverability factor, and
3.5. there's a very easy
way to create a hyperlink to "here".
I do not have time to show this now,
but for example, if I'm
here in a tutorial and I think that this
section is something interesting, and i
want to create a hyperlink to it
i just have to type a certain key
sequence - `M-h M-h' - here...
and here I got a hyperlink that I can
copy to my notes, and this hyperlink goes
to that section.
3.6. We have hyperlinks that point to
specific positions in
PDF documents and in video files... here,
this one opens a PDF and displays it,
this one opens a PDF
and converts it to text,
and this one opens a video in a
certain position.
3.7. And we also have a way to control
shell-like programs.
In my presentation of the last year I
spent one third of the presentation
explaining this, and
i think that I gave a very good
demonstration there...
the demonstration is here:
we can go to the web page, and go to
this section of the web page,
and start by this point...
and here we have an explanation,
and so on, whatever...
3.8. and i've already mentioned this
before... eev comes with a very nice
elisp tutorial.
So that's it, this is the end of part 3.
So this is the last part of my
presentation, and it's about the title
of the presentation...
I called the presentation "Why
most of the best features in eev look
like 5-minute hacks". I've already
run out of time, so I have to skip this
first part here, in which i describe how I
was exposed to several different notions
of user friendliness...
and how the one that really blew my mind
was the one in
a certain Forth environment...
and let me make the long story
very, very short.
In all this process I switched from
the belief that the "User" was always
someone else, someone external, and that
I always had to write my programs for
this external "User"... I switched
from that to the belief that _I_ am
the "User",
and I can play with the interfaces that
I want, I can write programs that
only I am going to understand, I can
experiment with hundreds of interfaces
and then select the best ones,
and document them, and then share them
with other people
who are also experimenting with
interfaces in their own ways...
and so eev has lots of things that are
user-friendly in these unusual ways that
I've explained before...
and if we disconsider that this
notion of user-friendliness is valid,
then these things that eev
implement they are user-friendly and
hacker-friendly at the same time.
And let me show one example. This is one
that really took me one only five
minutes to implement.
At one point, a few months ago,
I discovered
that Sacha Chua's weekly posts about
Emacs News were also
being posted to a mailing list that is
stored at
lists.gnu.org, and it's called
emacs-tangents...
and I found a way to create
the links to to the posts in both places,
but I had to use a template for that...
so what we are seeing here now
is a template with the default
values - so this means that we have not
set the year correctly, we have not set
the month correctly,
or the day correctly, but if we run this
sexp here...
let me do something else before...
if we run this sexp here
we change some of these entries
in the template, and we get these links
here... they all work.
For example, this one opens
the blog post in Sacha Chua's site,
and this one
opens it in the mailing list...
and sometimes I want the Org source of
that, and the easiest way to get the
Org source is to
look at this link here, that has an
attachment...
and if I take this
link here, and I take this
stem that points to the attachment,
and I put it here, and I generate this
page again
with all this data, then I get
a script - here -
that downloads... let me switch to a
smaller font -
it downloads this attachment,
and it renames that attachment to
something-emacs-news.org.
Here - the file is already here,
already with the right name, so I can
open it with just this hyperlink...
let me go to the big font again -
and now i have the Org source for that
hyperlink...
sorry, for that blog post,
and so this one-line thing here
is, in a sense, a hyperlink to
this blog post in all its formats...
if I execute this I get links to
to all the places where it is posted,
and I get a script to
download a local copy of the
Org source of it... and that's it.
Well, I'm already out of time, so let me
finish here.
Thanks! Bye! =)