How I write 5-minute hacks in eev with `M-x find-find-links-links-new' - DO try this at home!!!

In my presentation at the EmacsConf2020 I showed that many of the functions of eev started as 5-minute hacks and I mentioned that I used `M-x find-find-links-links-new' to create their first versions, but I didn't explain how people can learn how to use find-find-links-links-new themselves, because that's hard... people need to understand apply, backquote, ee-template0, and find-elinks, and there isn't an easy way to check what small changes do.

In this video I show a series of exercises - most of them very easy - that people can run to learn how to use find-find-links-links-new. They are all in the file foo.el.

...to be more precise: all the exercises in the first 43 minutes of the video are like "try this sexp and understand what it does", and they only need basic keys - and this include the steps that let us create a function called find-mytaskC-links, that is our 5-minute hack. Then things become harder: we need to see how the behavior of find-mytaskC-links changes after small changes in its code, and for that I define a bizarre hack that makes M-9j eval both the (defun find-mytaskC-links ...) and the sexp that shows its behavior.

^ Update: the "bizarre hack" in the second part of the video - from 43:00 onwards - can be rewritten in a much simpler way using eval-defun, but when I recorded the video I didn't know that eval-defun existed. =(

This video was inspired by a question by Bruno Macedo. I recorded it in 2021dec25.

Important: I don't know if this way of explaining things is clear or not - I haven't tested it on humans yet, and I would love to have feedback on it. So: if you get stuck get in touch, and let's try to arrange a chat by IRC!

The index of the video is here.
Its subtitles in Lua are here.
The rest of this page contains a conversion of the subtitles in Lua
to a slightly more readable format.

E-script: http://anggtwu.net/2021-ffll/foo.el.html
          http://anggtwu.net/2021-ffll/foo.el
                 (find-angg "2021-ffll/foo.el")

00:00 Hi! My name is Eduardo Ochs. I'm the
00:03 author of an Emacs package called eev, and the
00:05 title of this video is: How I write 5-minute
00:08 hacks in eev using this function here:
00:10 find-find-links-links-new.
00:15 This function is the successor of an
00:18 older function called just
00:20 find-find-links-links...
00:22 the new function is very similar to
00:24 the older one but the interface
00:27 of the newer one is
00:29 is a bit better, and it generates
00:32 better code...
00:34 and the subtitle is: DO try this at home!
00:37 because this video is mostly about
00:39 exercises that you can try at
00:41 home and that are very simple to perform...
00:44 I mean...
00:46 most of the video is about exercises
00:49 that are very simple because they
00:51 only depend on the main keys of eev...
00:55 and they are just
00:57 exercises like: look at this sexp here,
01:01 execute it, look at its target, and try to
01:04 understand what the sexp means...
01:07 but the in the last part of the video
01:09 I'm going to show how i write 5-minute
01:11 hacks in eev using this function here,
01:14 that was never very well documented, and
01:19 then the exercises are going to be a bit
01:21 harder, but not much...
01:24 and I'm recording this on Christmas Day
01:26 and this is why I decided to put here
01:29 an image about a Christmas tree...
01:33 and it's exactly my situation - I was busy
01:35 doing other things, and I did not
01:39 put lights on my Christmas tree, I was
01:41 just doing other things that I found
01:43 more fun... and also, of course, playing with
01:47 doggy. But whatever...

01:53 Let me show some videos...
01:54 I mean, just the title pages of some videos...
01:59 this video here
02:01 is the video of my presentation at
02:04 the EmacsConf 2020
02:06 its title was: On why most of the best
02:09 features in eev look like 5-minute hacks.
02:13 and I also recorded for the EmacsConf 2020
02:17 this other video that was a
02:20 companion to the first one.
02:23 The title of this video is: Some
02:26 template-based functions of eev that
02:28 are not 5-minute hacks...
02:31 and
02:32 one of the videos that I presented in...
02:35 sorry, one of the functions that
02:38 I presented in that second video was
02:40 exactly find-find-links-links-new...
02:44 and I also presented several functions
02:46 that were generated with
02:49 find-find-links-links-new, but
02:51 after I generated their prototype I had
02:54 to change it a lot, and this video was
02:56 about these functions that had
02:59 some non-trivial tricks inside... but they
03:01 were
03:02 also generated by the same function that
03:04 we are going to discuss now, which is,
03:07 again, this one: find-find-links-links-new.

03:13 So...
03:17 all the material that we are going to
03:19 see is in this file here...
03:22 you can look at an htmlized
03:26 version of it here... in the html version
03:29 some of the hyperlinks work...
03:33 and
03:35 the main page about this video is this
03:37 one here, and in this page you're
03:40 of course going to find links to the to
03:43 recording of the video in .mp4 and to
03:46 this
03:48 file here, that we're going to to see now...
03:50 the file with the exercises.

03:54 So let me start by reviewing one
03:57 important thing.
03:58 One of the main keys in eev is `M-e', that
04:03 executes the sexp in the current line...
04:07 and
04:08 the standard function
04:10 in Emacs for
04:12 getting help about a key is `C-h k'...
04:16 so if I type `C-h k M-e'
04:20 I get help about `M-e'. I get help
04:23 that looks like this...

04:26 so this is the description of the
04:28 function in a human readable form,
04:31 with several clickable buttons here, and
04:33 here, and here, and formatted in a nice
04:36 way...
04:37 and this
04:40 link here goes to the source code of the
04:42 function.

04:44 So this is the Emacs way of getting
04:47 help about a key, and the eev way of
04:50 getting help about a key is with
04:52 this key sequence here...
04:55 with `M-h M-k' instead of `C-h k'.
04:59 So, I can type `M-h M-k M-e'...
05:04 note that here it says "elisp hyperlinks
05:06 for key"...
05:08 and instead of getting a page
05:11 that is very human readable I get
05:13 this page here, that is very hacker-friendly,
05:16 that only has a series of
05:18 elisp hyperlinks...
05:22 and instead of
05:26 talking about these key sequences
05:28 and expecting that people are going
05:30 to understand the key sequences when I
05:35 pronounce them
05:37 I'm going to use this trick here...

05:40 the function `eek' works...
05:42 I mean, a sexp like this, that starts
05:45 with eek, works as a button
05:48 that when we press it its action
05:50 corresponds to the action of
05:53 typing this key sequence here...
05:56 this thing here is a comment and it
05:59 is ignored.
06:01 So I can either type M-h M-k M-e,
06:08 or I can execute this sexp... but I think
06:11 that it's going to be easier to...
06:14 the exercises are going to be easier if
06:16 people just have to look at a sexp like
06:18 this and execute the sexp.

06:21 So,
06:22 this sexp here go to my page with elisp
06:25 hyperlinks about `M-e'...
06:31 and one of these elisp hyperlinks is
06:34 exactly this one here
06:37 that produces the description of the
06:39 function...
06:40 the description of the function
06:43 ee-eval-sexp-eol, that is
06:45 associated to M-e... and this
06:48 description is quite similar to what we
06:51 saw before...
06:58 by the way, this thing here goes exactly
07:01 to the help about the key in [???]...
07:04 in the max it is quite similar to what
07:06 we saw...

07:09 but what matters is that
07:12 this sexp here is a refinement of the
07:15 previous one...
07:17 this sexp... this longer sexp here
07:19 is going to
07:22 create the same temporary buffer as
07:25 this shorter sexp here, but it also
07:28 searches for the first occurrence of
07:29 this string...
07:31 and then for the first occurrence of
07:33 this string after that.

07:35 Let's try...
07:39 this is the first occurrence of
07:41 "If ARG is:" and this is the first
07:44 occurrence of "2:"...
07:47 so this sexp here points
07:50 to this explanation,
07:52 that says that when we execute `M-e' with
07:56 the prefix argument 2 the effect
07:59 is this: we eval the sexp in the
08:01 current line and we show the target of
08:03 the sexp in another window.
08:06 Let's try...
08:08 because this is not very well documented
08:11 not everyone knows this...
08:15 I'll have to use a smaller font...
08:19 if I execute this sexp here with `M-2 M-e'
08:23 the target is shown at the window at the
08:26 right,
08:27 and the
08:29 active window is still the window at the
08:31 left...
08:37 and this is nice because we can use this
08:40 to see the targets of
08:43 several sexps without
08:45 losing this window here...
08:48 let me show this very quickly...
08:49 M-2 M-e, M-2 M-e, M-2 M-e...
08:55 and so on. Oops, sorry...
08:59 ok? So i'm going to use M-2 M-e
09:02 a lot.

09:09 This sexp here points to a section of
09:13 the main tutorial... the main tutorial is
09:15 find-eev-quick-intro,
09:17 and this section, 7.5,
09:19 is the first one that
09:22 explains what is one of these
09:25 5-minute hacks that
09:28 got more things and became something
09:30 more than 5-minute hacks... something
09:32 that took much longer to write
09:35 and that has extra features...

09:38 And, so, among all these
09:42 5-minute hacks on steroids
09:45 the one that is
09:46 mentioned first in the tutorial
09:48 is find-latex-links, so let's see how it
09:50 works.

09:52 First of all, this sexp here
09:56 points to its source code,
09:59 and we can see that its source code is
10:02 here... this is the definition of
10:04 find-latex-links, and we can see that the
10:06 definition, the defun, is preceded by
10:08 a series of comments...
10:10 including a comment that points to that
10:13 section of the manual...

10:20 ...and these things here are tests.
10:23 If we execute...
10:25 let me use a single window here...
10:28 if we execute this sexp here
10:32 we get this temporary buffer...
10:35 if you execute this sexp here
10:38 without the /tmp/foo
10:43 we get this, which is quite similar, but
10:46 you can see that some in some places we
10:48 see a "{stem}" between curly braces...
10:53 and it is this {stem} that is going to be
10:55 replaced by this argument here.

10:59 So let's try again. Pay attention to all
11:01 these "{stem}"s here...
11:04 this one, and the ones in these other
11:06 places here...
11:09 they were all changed by "/tmp/foo".

11:17 This one is a bit weirder because it
11:19 generates exactly the same
11:23 buffer as the first one, except for this
11:26 extra argument here... and this extra
11:27 argument means...
11:31 go to the second line of the buffer.
11:36 And if we execute this one
11:39 it goes to the second line of the buffer
11:41 and then it searches for the first
11:42 occurrence of "copy-rest", which is here...
11:46 and this sexp here...
11:50 so, note that this text here points to
11:52 this temporary buffer
11:54 and to this sexp in the temporary
11:57 buffer, and this sexp in the temporary
11:58 buffer points to a position in the main
12:01 tutorial...
12:03 which is this mention of `ee-copy-rest'.

12:09 So this is a feature that is important
12:12 but we are not going to
12:16 test it now because
12:18 our focus now is how to write this
12:22 these functions... and this is one
12:25 of the advanced features of these
12:28 5-minute attacks are these [???]
12:30 template-based functions and it's
12:33 not very important now.
12:36 so let's go back...

12:37 We were here...
12:40 so we were taking a look at
12:42 find-latex-links and
12:45 the links in its comments...
12:48 note that find-latex-links is defined
12:51 in a file called "eev-tlinks.el"...
12:56 this sexp here just opens
12:59 the file eev-tlinks.el
13:03 in the directory of the source files of
13:05 eev...
13:06 so let's run it now, it opens that sexp
13:10 and it doesn't go anywhere, it just keeps
13:13 the cursor - the point - where it was...
13:18 which means that if we execute this one
13:21 first
13:22 it will go to this position and if
13:24 execute this one second
13:27 it will not change the position of the
13:29 point...
13:31 but this was a parenthesis...

13:38 this sexp here points to something
13:40 important. It points to
13:42 the section of that source file that is
13:46 the main... uh...
13:49 it is standard in Emacs that
13:52 all source files
13:54 must have a commentary here... a commentary
13:57 in the beginning of the file, formatted
13:59 in the this way, starting by a line
14:02 like this, with three semicolons in the
14:04 beginning...
14:06 and this is a general description of
14:08 what this file is...
14:11 and this commentary
14:14 explains that this file
14:16 contains several functions similar to
14:19 find-latex-links,
14:21 that produce buffers made of a series of
14:24 hyperlinks followed by a templated text...
14:29 the templated text is usually preceded
14:31 by a line like ee-copy-rest blah blah
14:33 blah blah blah... ee-copy-rest is the
14:35 thing that I do not want to explain now,
14:39 and the functions here are one
14:41 complexity step above the functions
14:44 in this other file here...
14:46 and the functions in this other
14:48 file here are the functions that
14:51 just have
14:52 a series of elisp hyperlinks...
14:54 for example, this one...
14:57 so this is just a series of elisp
14:59 hyperlinks, without the templated text at
15:02 the end.

15:05 Let me go back... where it was...
15:07 "Commentary:" - ok.
15:14 now this sexp here points to the first
15:17 occurrence of "five-minute hacks", and let's
15:20 read this paragraph...
15:22 many of the functions in this file are
15:25 5-minute hacks
15:27 whose first versions were written in two
15:29 steps...
15:30 in the first step I ran
15:33 our favorite function,
15:35 M-x find-find-links-links-new,
15:37 and then I adjusted the arguments in the
15:40 first line - we are going to see how to do
15:42 that...
15:43 the first line of the temporary buffer...
15:46 and I regenerated the buffer -
15:48 and this gave me a skeleton for the real
15:51 function... and in the second step I
15:53 adjusted
15:55 the
15:56 arguments of the `find-elinks', which is
15:58 something that is in the middle of the
16:00 skeleton, so I was putting flesh in the
16:03 skeleton...
16:05 and I was putting flesh in the skeleton
16:07 in two parts...
16:09 in two positions... inside the `find-elinks'
16:11 and in the string inside `ee-template0'...
16:14 we are going to see that with examples.

16:20 And each function here in this file that
16:23 was written in this way has a line "Skel:"
16:27 like this, that if we run...
16:30 well, if we run this line, "Skel:",
16:34 we regenerate the skeleton...

16:43 and this thing points to and old video,
16:46 that explains that but not very well...
16:50 and let's see an example... let me go back
16:54 to this function here, find-latex-links,
16:58 remember that this sexp here
16:59 here points to the source code...
17:02 so I'm going to execute it, here's the
17:05 definition of find-latex-links,
17:07 and this is the line that says "Skel:"
17:10 blah blah blah...

17:11 If I execute this line I generate a
17:13 temporary buffer with something similar
17:16 to this definition here, but without
17:19 the meat inside, just the outer parts...
17:24 which is this...
17:26 here we see exactly a copy of that "Skel:"
17:29 line, here we see a test, here we see
17:33 the template that we need to change
17:35 later.

17:39 So this is a general idea...
17:48 but let me start by showing
17:52 some...
17:53 well, eev has lots of functions
17:56 written in that way, including some things
17:58 that I wrote very quickly and I just
18:00 thought that they were nice and I
18:02 decided to
18:04 include them in the source code.

18:06 Let me start by showing some of these
18:08 functions, because some are really
18:10 five-minute attacks, and it's easier...
18:13 it's very easy to look at them and
18:14 to understand how they were written.

18:18 First, if I
18:21 execute this thing here I get help about
18:24 the function eev-mode.
18:26 You can also get help about it in other
18:28 ways...
18:30 for example, note that there's an "eev"
18:33 here, in the mode line, and this "eev"
18:36 says that eev is one of the
18:39 active minor modes...
18:43 and if you click with the second button of
18:46 the mouse here we show help for that minor
18:49 mode... we get this thing here,
18:52 which is quite nice...
18:55 but we can also get that help by
18:57 executing this sexp here...
19:00 as always, if we execute this we get lots
19:03 of links, and find-efunctiondescr
19:06 is one of these links...
19:08 I've copied it to my notes here...
19:12 and if we execute this sexp here
19:17 we get exactly that description...

19:22 and this description says that this
19:26 function, eev-mode, toggles eev-mode, which
19:29 means it either activates or deactivates
19:33 this key map here...
19:36 and
19:39 this help also says "Only the main keys
19:41 of eev are listed below.
19:44 For better lists...", I mean, for lists that
19:47 are more complete but that do not distinguish
19:49 the important keys from the secondary
19:52 keys, see blah blah blah blah.

19:56 And one of these links is
19:58 (find-keymapdescr eev-modemap), that describes...
20:04 that receives a data structure that is a
20:06 keymap and shows the description of
20:08 this key map in a nice way.

20:11 I've copied this sexp to my notes here...
20:15 let's execute this sexp here with M-2 M-e...
20:19 this is a description of the keymap, and
20:22 it has some very obscure functions here...
20:26 obscure but nice.

20:28 If we execute this other sexp here -
20:33 this _longer_ sexp -
20:35 this sexp here is a refinement
20:36 of the sexp above, this shorter one here...
20:41 and this refined sexp searches for the
20:44 first occurrence of "find-eface-links"...
20:48 and this "e" means Emacs.
20:53 I use this prefix "find-e" to...
20:58 sorry, I use these functions, with these
21:00 names like "find-e blah blah blah blah
21:04 blah blah -links"...
21:07 I use these names for functions that
21:09 describe
21:11 data structures of Emacs.
21:14 So,
21:16 there's a function here that is
21:18 find-eface-links, and this hyperlink
21:21 points to it...

21:23 you can see that the cursor
21:25 is here, here is the first occurrence of
21:27 this string...
21:29 and in this
21:33 description of the keymap it says that
21:36 this function is bound to this sequence
21:38 of keys: M-h M-s.
21:42 So we can also get help about that key
21:45 sequence, M-h M-s, by
21:48 typing M-h M-k M-h M-s,
21:52 or by executing this sexp here. Let me
21:54 execute this sexp...
21:56 here we get a series of hyperlinks
21:59 about
22:00 M-h M-s,
22:03 and one of them points to the
22:06 source code
22:09 of that function...
22:11 that even includes a commentary saying
22:14 that it's bound to M-h M-s,

22:17 and it has a test here, and this is the
22:20 nice part.
22:22 We also saw what the skeleton does...
22:25 it generates something here that we're
22:27 going to understand soon... and the test
22:31 is going to show some links about this
22:33 face here.

22:36 so, for example...
22:42 this goes to the description of that
22:45 face... doesn't say much...
22:50 this goes to the source code of that
22:52 face...
22:54 so it was defined by this defface here...
22:58 and here we have a comment explaining
23:00 what it is... this is the face used by the
23:02 red star glyph... remember that we can get
23:05 red stars by typing C-q C-o.
23:11 That's it

23:15 So... we have these
23:17 mysterious
23:20 hyperlinks here... that are mysterious but
23:22 I've included them because I thought
23:24 that they were interesting...
23:28 and you can try all of them by yourself.
23:34 And, in particular
23:36 we have this one here
23:38 that shows links about a color...
23:42 about what Emacs knows about this
23:44 color... note that it has an "e" here...
23:48 so here we have several elisp hyperlinks
23:50 about
23:52 red...

23:53 and if I execute this one
23:57 I get a color chooser
24:01 that starts with red, but let me change
24:04 the color...
24:07 and after I
24:09 return
24:11 this color chooser...
24:13 this function here changes the color to
24:16 to another one - to the one that I chose.

24:19 But let me go back to red one second...
24:22 this is something that is interesting...
24:24 that is not a hyperlink -
24:28 you should
24:29 understand it as a button that does
24:31 something when we click on it...
24:34 and if we execute this sexp here
24:37 it inserts this text here, "Sample",
24:42 with this color
24:44 in the background...
24:46 so this is a sample of the color red.

24:50 Let me undo this...
24:51 and this thing here
24:53 converts red to
24:56 this string here,
24:58 but it shows the result here
25:01 in the echo area... etc etc.

25:04 So
25:06 we were looking in details one of these
25:10 five-minute hacks of eev that I've
25:12 included just because they were useful
25:14 and they were interesting...
25:16 eev has lots of these things...

25:19 sorry, we saw
25:21 one about faces and one about colors...
25:25 and we are also going to see a few more
25:28 before understanding how to
25:30 write them...

25:33 and
25:38 let me see if these things have
25:40 something new...
25:42 no, it's just the same thing as before -
25:45 I messed up with the other and I
25:48 explained some things before I planned.

25:51 So this thing here gets as a sample of the
26:00 color "chocolate1"...
26:05 this thing here
26:07 lists all colors - all the named colors
26:11 that Emacs knows...
26:13 and this thing here lists all the
26:15 named colors
26:18 and looks for the first occurrence of
26:20 chocolate1
26:22 in this list.

26:24 So, lots of
26:27 small funny things, and
26:29 as always you can
26:32 look at the source code of one of these
26:34 things, try to understand how they
26:36 are implemented, and so on, and so on...

26:42 Let me show one more of these
26:47 five-minute hacks that I think that
26:49 are very interesting...
26:52 if I execute this sexp here
26:55 it shows several links about an Emacs
26:58 package... in this case
27:00 magit is a package that is installed, so
27:03 my function knows...
27:08 it has some tricks for finding the
27:11 directory in which it is installed...
27:14 and
27:20 if execute this it shows the directory
27:22 in which this function is installed...
27:25 if I run this sexp here
27:30 first
27:31 Emacs...
27:32 this sexp calculates obtains a data
27:34 structure about... with the description of
27:37 this package,
27:38 and this find-epp
27:41 formats this - pretty-prints this
27:44 data structure in a nice way...
27:47 so we get this...
27:49 we get a lot of information about this
27:51 package in a
27:52 very
27:54 technical format... we are just
27:57 looking at the data structure that
28:00 Emacs uses for that...
28:03 and this other sexp here shows the same
28:06 data structure in another way,
28:10 with the
28:11 numbers of the fields...
28:13 so this is a very low-level description
28:17 of what is this data structure...

28:19 and this sequence of sexps here...
28:25 I can use them for several things but
28:27 they are especially nice when I want to...
28:29 when someone mentions a package to me -
28:32 for example when I'm on IRC and someone
28:34 mentions a package, and I want to install
28:37 that package very quickly, look at its
28:39 description, look at its source code and
28:41 maybe delete the package later...
28:44 so, if I execute these sexps one by one
28:47 I make Emacs load
28:49 the list of packages
28:51 including ELPA, MELPA, etc, and I make it
28:54 install the package,
28:56 and make it look at its description...
28:59 here the package is already installed...
29:01 and the description...
29:03 sorry,
29:06 let me run this just to make sure that
29:08 everything is going to work... this takes
29:10 some seconds because it has to connect
29:12 to all these repositories...
29:14 so a bit of patience, please...

29:19 the package is already installed, so if I
29:21 look at this
29:23 I see a lot of information, including the
29:26 description, and the dependencies, and
29:28 blah blah blah...
29:31 and also
29:32 the official website of the package,
29:35 which is quite nice...
29:37 sometimes I want to look at the website.

29:45 and
29:47 so
29:48 this
29:49 yields
29:50 the directory in which the package is
29:52 installed, this
29:54 uses this directory and opens the
29:57 directory and shows its contents... so now I
29:59 can look at the source code of that
30:02 package...

30:07 By the way, just a parenthesis: I'm just
30:09 showing these nice five-minute hacks
30:12 because
30:14 one of my intents with this video is
30:16 to make people
30:18 experiment with these five-minute hacks
30:20 and explore the sexps that they show...

30:23 So, if you execute this sexp here
30:28 you are going to get all the sexps here at
30:30 the right, and I want to
30:32 convince people to play with sexps to
30:35 understand what they do, and also to
30:39 look at the source code of the functions...

30:42 so, for example, if people want to know
30:44 what find-epp does...
30:47 let's just find... Emacs pretty-print...
30:50 we can
30:51 go here to the source code, that has lots
30:54 of comments.

30:56 Let me go back. So, again...
31:04 this is a low-level description of the
31:11 package-desc structure
31:13 of that package.
31:15 This is another low-level description...
31:21 and these things here
31:24 use the url...
31:27 the second one is more interesting. If
31:29 executed
31:31 it inserts a line... let me redo it here...
31:35 if I execute this text here...
31:38 sorry, wrong key... oh god! Sorry...
31:41 if execute this thing
31:44 it inserts a line with this
31:47 hyperlink here, and I
31:48 can visit
31:50 this url using a browser. I'm not going to
31:53 to do that now
31:56 and if I just install the package just
31:59 to check what was inside and I want to
32:01 delete it immediately I can
32:03 execute this package-delete here... but I
32:06 do not want to do that now.

32:10 and this is a hack that
32:14 uses ee-package-dir to
32:18 discover the directory in which the
32:20 package is installed...
32:22 and it regenerates this buffer here
32:25 using this directory...
32:28 I had to use this hack because
32:31 ee-package-dir does not always work,
32:34 so I prefer to
32:36 not use it by default...
32:39 and again, if execute this I regenerate
32:42 this buffer with the right directory,
32:46 and I can copy this thing to my notes...

32:50 and this thing here
32:54 is a short hyperlink to this directory...
32:59 so if I find something interesting here...
33:04 suppose that this thing is interesting...
33:08 I can just use
33:11 this thing and copy to my notes and I
33:13 have a short hyperlink to that.
33:17 So this is a link to one specific file
33:20 in the magit source code
33:22 and to the first occurrence of "SPDX",
33:25 which is something that I do not know...
33:27 I've never seen it before so I found it
33:29 interesting.

33:32 [I haven't subtitled the rest]
34:00