Hello, and welcome
to my Org GTD talk.
I wrote this package because I was
overwhelmed with all the stuff I had to
manage working at home.
I'd heard about GTD. I saw someone
using it with
just a small notebook.
I wanted to do it in Emacs because,
well, Emacs can do everything, right?
I'm going to jump in quickly. Just so
you know, here's kind of a list of the
resources. Obviously, org-gtd, which you
can find there. You can open an issue, ask
me questions there about it.
I use org-edna, a package for state
triggers. I'm going to show this briefly
when I finish item in a project.
org-agenda-property, you will see in the
agenda. It's going to show
to whom an action has been delegated to.
You will see org-roam briefly as a
reference because that is what I have
chosen for my knowledge archival tool.
You can choose
whatever you prefer.
This is a quick, quick reminder on
what GTD is and how it works. This is not a
lesson on--a presentation on gtd because that would
be... Well, other people have done it better than me.
In short, everything goes into the inbox.
Then you process the inbox, and you
decide what to do, if
it could be actionable or not. If it's
actionable, it could be a project
or it could be a single action, which you
could delegate
or schedule or just
do it. If it's not actionable, you could
just throw it away,
incubate it for later, or move it into
your files, reference.
Over here, you can see the global bindings
for org-gtd. Those are the actions,
the functions I have made available.
This is in progress. There's more to come.
Some stuff is probably missing.
It's grown mostly from my own personal
use so far, so it doesn't have things.
In the bottom right, you can see the agenda.
One thing I wanted to do with this package
was leverage Org Mode as much as possible.
So I tried to not reinvent
the wheel as much as I could. That meant
reusing the agenda. You can see here
a couple of the things that are made
available or kind of
customized or configured for you,
some of the opinions that org-gtd has.
Up here, for instance, you can see a
delegated action.
So a delegated action
has someone to whom it's delegated. It's
my parents in this case.
It has the name of the action: ask
parents what gift they want.
It's marked as the state
of WAIT because I'm waiting.
It is scheduled because you should
ping people or check on the status status of a task
when you're waiting for it, so you don't
forget about it or it gets lost forever.
I have a scheduled action to give a talk.
That's what I'm doing right now.
I have an incubated action which is
also scheduled: to make money through the lottery.
This is a thing to take a look at
for later, decide later what I want to do.
It might be actionable, it might not be.
I don't know right now, or I didn't
know when I processed it, so I incubated it.
Underneath, we have all the things that
are direct actions for me to take.
All right. You see a little bit of the
preparation seeps through the actual talk.
I have here two... I have a single
action of "Steal Andrea's
GTD configuration"
and an action to read the GTD book.
It's part of a project.
So most of the day-to-day operation with
with this package should come through
just having the agenda open
and having it be your source
for the information you need to know, so
that you can do the right thing. So let's take a look
at what's underneath all of this
really quickly.
We have--There's three primary files.
We have the inbox.
I'm gonna process it in a second
because there's two things here. One thing to cancel, like
an action to not take. It's nothing. And then something
I will just put into org-roam, just so
you can see that there is the incubate file.
You can see here: make money through the lottery,
captured, refiled here, and scheduled
so it would show up in the agenda
right at a given time. On the right,
you have the actionable file. This is
the one that has the most information,
where most things should go.
So I have the single actions. They all go
underneath here.
This is marked as next because it's an
action for me to take.
Delegated is marked as WAIT. It is
not an action for me to take. It's an
action for somebody else to take, but it
is scheduled because
I may wanna... I can check in at some point.
Things that are scheduled, like "give a
talk," do not have a TODO or NEXT or WAIT
state because they are not bound that
way. They are time-bound,
so they will show up in the agenda when
the time comes. I shouldn't act on them
or I can't act on them beforehand.
You can see here, I have two projects: a
test project (and I will
do something with this in a second)
and then there's this
package "Make a GTD package." There's a
project here for me to create this.
It's made of a bunch of actions.
I'm going to show you two things here.
One is: since I was trying to leverage
Org Mode as much as possible,
I didn't try to create very clever
operations, because Org Mode has a lot of
very powerful tools already.
There's automations I can add,
but I thought it might be
better to leave more things in the
hands of the user.
So here, in this case, this test project
we can just archive.
Right. That's just
C-c C-x C-a is the
org-archive action. Save this.
So now if we go to...
This will create an archive file
which will have this information
for later perusal
if you're interested.
That's one thing. If we go back to the
agenda for a second,
you can see
these things here. Org. So by the way,
this "parents" here was the org
agenda property. This is what shows here,
right? And here, if I finish "Read the GTD book,"
I mark it as done. Now refresh.
You'll see that another item shows up,
and that is where org-edna comes in.
When an action is marked as done in a project,
the next to do action is
automatically marked as next, so your
agenda is automatically updated.
This was one of the nice things for me
because I didn't want to have to
open my file, go find the action, mark it
as done, find the next one, mark it as
next, and so forth.
I didn't want to bother with it.
Oh, actually, you know what, let me show
you something else.
This simple project... I don't need this timestamp to
be here but I like having a capture timestamp here,
so I'm gonna make one up.
So this is the most convenient thing
that I think...
This is one of the most convenient
things that I get out of this binding.
The next really convenient thing is the
way this gets processed.
Let me show you this.
When you process the entire inbox,
what you see is
the items one at a time, so you can work
with them.
You can see at the bottom... You can
work with them without being distracted.
You can see at the bottom the list
of things you can do, which are all the
decisions you can take from GTD, right?
In this case,
this is one to throw out, so press t.
You have the option to make modifications to
this if you want to.
If you have any reason to store it, then
you finish editing.
You can add a tag if you want to, because
this might still be interesting,
and then enter and it's done.
Important knowledge,
I'm going to hit a for archive it.
I'm gonna start looking at org-roam.
So this is important knowledge.
I have to capture this. That's it.
I've captured it.
It is done.
I go back to buffer,
and I can mark it with C-c.
There's no archiving because this is
just knowledge. There's no
tagging. It's just knowledge. But then the
simple project... I want to show you this
because there's some automation that's pretty helpful.
In the simple project, I have my first action,
second action, third action.
and you see, this is all I'm writing.
I'm not adding any of the states, any of the
tags. They're going to be added by...
Here, I can add a tag
if I want to this project.
I don't care
right now, but you know... I leave the tags
to the user, so they're not super
relevant to me as a package provider.
This is where we are. This is
the whole thing. So now if we go back to
the agenda,
I have a first action, right.
And if I go to the actionable file, and now
see, I have a simple project that has my
first action as NEXT,
second option TODO, third action as TODO.
So what I've... You know,
as you can see... I hope what I've tried to
do is take all of the
tedium out of working with
with Emacs and Org Mode when working
with your actions so you could focus on
what you want to do, what you need to do,
what you care about, and the package
would take care of the rest.
So the last thing I wanted to take a quick
look at was some of the the tests.
The code is available here. You can
see the code on...
the code on Github if you want.
I've had some trouble writing good tests
for this because Org Mode was written at
a time before testing was quite as important, I think,
or valued quite the same way,
let's put it this way.
And as a result, a number of things actually...
It might also be a feature of Emacs at
the time, I don't know.
But a lot of things in Org Mode aren't
very testable, and so
what I ended up doing was just having an
actual directory in which I
actually... with files,
right? So I don't have much mocking
I can do. I can't just do a bunch of fake
files, fake directories.
So I actually go through the process,
actually create files, and then actually
have Emacs pointing at this
directory to process and get the information.
So I have to define the key to test that
it gets bound properly.
I have to set the capture templates.
The capture templates are how
things get added. I have a wrapper
control... org-gtd-capture essentially is
a wrapper around the capture that
makes sure the inbox is there and then
captures to the inbox.
Making sure the items show in the agenda
when I'm done with the processing
was a little bit tricky. I had a bug and I had to to fix it,
so I just wrote this test, but it's it's pretty convenient now
to have that, because it gives me a
bunch of sanity. So again, I have a
capture, and this is...
I wanted to be able to do this
automatically but org-capture itself
is not super testable right now,
so the way it's...
the way you test it is just by
programmatically calling it, which
is not exactly what I wanted, because I
wanted something more like
the user action, but I'll... You know, what I
can get.
And then I can... I'll just insert these
words into the buffer and then
I'll finalize the capture. Then I have
another... I have a test package here
called with simulated input which
basically calls this and then enters
these user actions. Right, so
like the letter s,
C-c c and then RET. And that is,
you know, choosing a single action,
then finishing the edit,
and then adding zero and not adding tags.
As you can tell, there's a strong layer
of disconnect between the tests
and what they represent. That's a work in progress.
I have four tests.
It's not a lot, but I want to... I intend to
add more as I keep on adding more behavior.
I would like this to be eventually
a sane starting point for GTD.
There's a lot of people like
like Andrea, like Rainer, like...
I mean, if you search for Org Mode and
GTD, you'll find
a lot of blog entries, a lot of
entries, a lot of articles that explain
how to connect it together, how to think
that way, how to use all the tools that
Org Mode makes available.
Hopefully, this package is a way to
get started without having to write
too much of your own code.
Then eventually, you can move away from
the package if you want, if you realize
that you are developing different opinions
and you don't want to...
If GTD doesn't work this way for you, if
you have a different way,
it is a better fit for the way you want
to organize your life,
then move away from the package.
In the meanwhile, I welcome all thoughts.
I welcome contributions. I welcome
questions, bug reports, everything
So, you know, come say hi. Try the package.
And yeah, see you.
I'll see you online!