Another poster mentioned Cal Newport's "deep work", which seems a more natural fit for coding to me.
I'm not saying GTD can't work for you, YMMV, but I think it's a better fit for more traditional office work.
Like, with Rust, I put in that I wanted to go through The Rust Book. I created a project with the book's title and a link to it in an org file. I created subheadings and turned them into TODOs for each chapter. Since I use org for literate programming, I included every example in this file along with my own exploration and toying with the language.
But an actual programming project won't be done that way. At most, from a GTD perspective, I note that I want to create a CLI TOTP implementation in Rust (as an exercise project). I'll capture it at a high level so I don't create too many projects (an unfortunate habit) and not finish it. So in my GTD list of projects I'll see that I'm working on "CLI TOTP in Rust", but no more details.
The details for that go into a literate programming org-mode file that drills into the details of what needs to be done. Somewhat GTD-style, but the tasks here never make it into my overall GTD action queue or schedule.
Basically, my system is an amalgam of what works for me at different levels. Dogma is rarely useful, in my experience. Flexibility and appropriation of tools from everyone else. Experiment, recognize failed experiments, latch onto personal successes, and explain what worked or didn't for me to others to help them do the same.
It's a fancy outline mode in emacs.
(NB: You can use it easily in Windows, just go to the GNU Emacs home page and download the emacs binaries, I do this for work where we're a Windows shop.)
Simplest features, outlines:
* This is a headline
This is my content
** This is a subheading, it's been folded...
* This is a headline
This is my content
** This is a subheading, it's not folded
More content.
It's a plaintext markup format, akin to markdown but not the same rules.Markup rules:
*bold*, /italic/, _underline_, =monospaced, good for code=
You can make enumerated lists or unenumerated lists: * A heading
1. List item
2. Another item, folded...
* Another heading
- list item, no enumeration
- another item
- sub-item
NB: Emacs shorthand: C-(character) means press Ctrl+(character), C-(character)-(character) means press Crtl+character, continue holding control and press the next character (the characters are pressed in sequence, not simultaneous). M-(character) means, on windows, the Alt-key (left-alt specifically?).Going fancier, let's make a TODO item!
* Project
** task
** Another task
On each heading, press C-t * TODO Project
** TODO task
** TODO Another task
You finished task? C-t again * TODO Project
** DONE task
** TODO Another task
You can do more configuration so it includes the time and day completed. You can change the workflow away from just <none>/TODO/DONE, as well. For code projects I have BUG/FEATURE/TRIAGE as well. TRIAGE indicates a possible error that's been discovered and its details are in the contents. BUG indicates that a bug has been identified and its details. FEATURE is a request and its details.Check out their site (http://orgmode.org/) for a lot more details. It can do a ton of things. If you really want to get started, just treat it as an outliner to begin with. Start using additional features as you need them. Like emacs and vim, it's a tool that you can grow into.
At the top of all of my org files is at least this directive:
#+STARTUP: indent hideblocks content
indent means that the outline will look like: * header 1
* subheader
content
Instead of: * header 1
** subheader
content
It's cleaner, IMHO, and the second version is the actual file contents. It's strictly a change to the presentation.hideblocks means that codeblocks and the like are hidden to begin with when I open the file:
#+begin_src c
void function(void);
#+end_src
becomes: #+begin_src c...
content means it'll show all the headlines, with their contents folded up. * H1
* H2...
* H3...
* H4
You can make schedules in it. Make checklists in it. Write code in it (literate programming). You can export it to LaTeX and HTML and other formats. You can tag headers * Tagged header :work:broken-feature:
And search those tags. I'm not sure how much else to say, it's big. But read the site. Play with it. Realize you want to do something, google that task and org-mode and someone probably wrote a blog explaining how to do it in org-mode.EDIT:
org-mode is included in the default emacs builds. You don't have to seek it out, though it does get updated independent of emacs. Emacs has been getting frequent updates the last few years, so you're usually not a major version behind if you just grab the emacs distribution and use its org-mode.
org-mode does sometimes create breaking changes in their formatting. But this has only bitten me once, and that was with a file I made in 2010 and reopened in 2014. The changes (forgot the details) needed to conform to the new formatting rules were not big. The biggest hit this last time I think was with the publishing directives and system.
It's fully, and easily, extensible (once you learn the language, emacs lisp in this case). I use Visual Studio at work for C# projects. Extending it is a non-trivial thing. If I just want to change a simple behavior of the editor, it's non-obvious where to start, and it's probably not as easy as writing a simple 3-line function and putting it in a configuration file.
Emacs, vim, Sublime (ok, no experience with it, but it seems easy from what I've seen), and others reduce this down to:
Create the function or functions
Put them in a specific file or the file in a specific
directory
At most reload the whole editor, but more likely just
tell it to refresh its plugins or to execute that bit of
code
org-mode, for me, is just a very, very useful tool that covers a lot of use-cases for me, and works across each OS that I use (Linux, Windows, macOS). But it's always worth exploring to find what works for you. If nothing else, you'll have "wasted" your time learning how to use emacs, and should you find yourself "stuck" in it, you won't be lost in the chords.
Using org-mode (other tools work as well, but particularly useful if you're fluent in emacs).
Full-screen apps, or two apps side-by-side. Specifically terminal, or terminal + reference (text, websites, man pages, PDFs). This helps to force focus on the specific task at hand.
My use-cases for org-mode: General project planning/management (personal, mostly); literate programming; notes while reading texts; notes while learning a subject.
Want to learn a new codebase but find reading dozens or hundreds of C and H files to be difficult to track? Slurp them into a massive org file that can spit them all back out using C-v-t (tangle). Then keep breaking the code down into smaller chunks adding notes, moving related sections in separate files closer to each other, etc.
Want to read a book and take notes on it? Half the screen is the PDf, half the screen is emacs. Create a headline per chapter, as you read, take notes. Write out definitions, use <<anchor>> content to create anchors for links like [anchor]. Write out your notes, capture things that you want to follow-up on, page numbers, etc. Each chapter and section gets marked as TODO (or customized) or DONE so you can chart your progress through the text.
Want to understand an RFC and maybe implement it? Put it into an org file, start structuring it, add in source blocks (or, if the RFC has source, turn them into source blocks as well).
===
And then there's GTD. Grok it. Understand that it's not a dogma but a toolkit. The tools exist to free you from the mental burden of tracking activities you need to do by capturing them, prioritizing them, dismissing them as needed, and scheduling them. If you aren't thinking about what's coming up, you can think about what's present.
===
EDIT:
Automate all the things. I write scripts to do a lot of my computer-based tasks. The purpose is to reduce error-rate (if there's an error, the script or the input was wrong, fixing the script fixes the former, adding a check to the input prevents the latter from recurring). It also gets things out of my head. I can literally forget how to do X, Y, and Z (frequent, maybe critical, but unnecessary for me to remember with any precision tasks). This is also useful for migrating a project from largely hand-rolled toward continuous integration/deployment (especially in my office where we don't quite have the infrastructure in place to do that properly or consistently). An example:
We get deliverables from contractors. My script takes that and pairs it with our own software, updating the libraries we link to with the ones they provided. Runs the build script. Constructs our deliverable. Pushes the output to a particular spot. Different parts of that are different scripts with one script to run them all. With a proper CI/CD platform, you could take each of these and put them in as stages triggered off things like git commits.
So now I've got these scripts, we have the git server and build server, I can restructure it all in a way that will run on that. Now I'm out of the loop. Whoever retrieves the contractor's deliverable and pushes it will also trigger the full rebuild of our system. No specific human is critical.
That's a specific work improvement, but the same can be done for many personal computer-based tasks as well. Like how GTD gets your future plans out of your head and into your calendar or whatever, automation gets your processes out of your head so you can focus on the product and inputs of the process and not the process itself.