Your note-taking process
Tags: productivity, programming, learning
Published: 2021-11-02 15:13:23

---
title: Your note-taking process
published: true
description: I've taken notes over the years with everything from plain text files to heavy apps like OneNote but for me this just blows everything else away.
series: An amazing note-taking system with Markdown and Git
tags: productivity,programming,learning
cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/84vqzavr3lu0wnj3jyni.jpg
---

I detailed my own personal note-taking process in the [last article](https://dev.to/scottshipp/my-note-taking-process-49pa). It is unlikely that your note-taking needs will be met by the same tools or the same processes.

I would now like to cover some other common use cases, and show how you might use other tools to build a process of your own.

## When you're not a heavy terminal user

Not everybody lives in a terminal and that's ok. Might the same approach still work within an IDE or a text editor?

I actually have set up both of the main text editors I use, [IntelliJ IDEA](https://www.jetbrains.com/idea/) and [TextMate](https://macromates.com/), with the same template that my [Noted cli](https://github.com/scottashipp/noted/) uses to produce time-stamped note entries.

My own reason for doing this is to double the goodness. If I happen to be in a terminal when I want to take a note, great! I just use _Noted_. If I happen to be in one of my text editors and I want to take a note, great! I don't necessarily need to switch over to a terminal.

Most text editors have some kind of templating / macro / snippet capability. In TextMate, I've set it up such that by typing "note" and then pressing the tab key, it produces a note entry, which as you recall looks something like this:

````

---

07:07:51 Pacific

# 

---

```

The way to set that up is outlined in the manual, but it is surprisingly easier than you might think. The timestamp is the difficult part, and that is accomplished fairly easily. If you happen to use TextMate, here is the actual template text:

```
---
`date "+%H:%M:%S Pacific"`

# $0

---
```

The backticks just execute a shell command and capture the output. The `$0` piece just instructs the editor to place your cursor there.

In IntelliJ, the related feature is called [live templates](https://www.jetbrains.com/help/idea/2021.2/generate-custom-code-constructs-using-live-templates.html) and you can make them do all kinds of wonderful things.

## When you have ADD / ADHD

I know that many people adopt strategies like [bullet journaling](https://dev.to/sumusiriwardana/a-simple-method-to-manage-your-work-effectively-4jmg) or the [Emergent Task Planner](https://davidseah.com/node/the-emergent-task-planner/) to help them focus. These are surprisingly effective strategies to get things done.

In either case, a paper notebook may actually be the best approach. Just because some tool isn't inside a computer doesn't remove it as an option! Sometimes the best tech pre-existed computers.


## When you want to set an alarm

You may want to remind yourself to do some task on some given date or time. Although there are plenty of great tools to do this, I find that most of them are rather heavy. Do you really need to run Outlook or the Mac Reminders app all the time just for this purpose?

(There's nothing wrong with using either, though, if you already use them all the time.)

For me, Slack becomes a good tool for such "alarms" or "reminders." You can set personal reminders by messaging Slackbot. Just open Slackbot's direct message and type `/remind help` to see a bevy of options. Or [read the help](https://slack.com/help/articles/208423427-Set-a-reminder). Whatever works for you.

On the other hand, Slack is a heavyweight tool itself. I wouldn't bet on Slack being open and running when I need to receive a critical reminder. Did you know there is something rather lightweight and built-in on macOS systems already?

To set a reminder that you will always receive regardless of what you happen to have open at the time, you can use a [cronjob](https://dev.to/kelvinvmwinuka/how-to-set-up-cronjobs-on-macos-523) to send a notification to yourself in the [macOS Notification Center](https://support.apple.com/guide/mac-help/notification-center-mchl2fb1258f/mac).

The only "difficult" part of this is deciding exactly how you want to send the notification to the notification center. You have many options including the two most common,  [Growl](https://dev.to/kelvinvmwinuka/how-to-set-up-cronjobs-on-macos-523) and [terminal-notifier](https://github.com/julienXX/terminal-notifier).

## When you periodically repeat a set of tasks

With all the automation in the world, there still tends to be quite a lot of daily or weekly tasks we do which in turn consist of a series of manual steps. I run into this frequently when some IT group thinks I shouldn't have API access to somewhere with data I need. I end up logging in through their GUI, downloading the data, importing it into some other tool, massaging it slightly, and then sharing it out.

It's dumb but it's the reality.

If you're the kind of person who likes to make sure you don't miss a step in such a process, then you need a step-by-step list that you can generate fresh each time and check off as you go. Actually, this also applies to you if the process in question doesn't happen very often (maybe it's monthly or quarterly) and involves some series of esoteric steps that you can't be bothered to hold in mind all the time.

I have found that Markdown isn't great for this but it still works much better than other ways. So I build a very basic Markdown "snippet" or "live template" with the entire process, similar to:

```
- Step 1
- Step 2
- Step 3
- Step 4
- Step 5
```

I used to prepend some series of characters like `[X]` whenever I had completed each step, but that experience is kind of meh. The better process seems to be to use strikeout to cross off each step when it is completed. This is usually represented with tildes, such as:

```
- ~~Step 1~~
- ~~Step 2~~
- Step 3
- Step 4
- Step 5
```

I'm still looking for a better way to do this, actually. The macOS Reminders app can be useful because if you set up a separate list with the steps, and configure all the steps to repeat on the same frequency, you will receive them all at once, but, again, the Reminders app is not as portable and flexible as Markdown is, and configuring all of that is a pain.

Someone really should work on making the equivalent of a paper pad where each sheet is the same template, items can be checked off, and starting on a new one is as easy as tearing off the top sheet.

## When you're a visual person

I personally don't think you can beat a paper notebook when you are visual. And, frankly, a whiteboard isn't a bad idea either.

I have a confession to make to close out this so far entirely digital diatribe. I still keep a [dotted Rhodia Reverse Book](https://rhodiapads.com/explore_bullet_dot.php) by my side all day every day. If I don't have one of those nearby (but I always do), I have also been just fine with [engineer's quadrille pads](https://duckduckgo.com/?q=engineer%27s+quadrille+pad&t=newext&atb=v288-1&ia=web) or I could make do in a pinch with a soft-skinned plain- or dot-papered Moleskine. I'm sure there's a reason that police detectives use vertically-spiralbound pads. Use what works.

## Conclusion

And that brings me to my final point. There are many options, and no single one of them is perfect for everyone. A customized approach seems to always work the best. 

I'd love to hear more from all of you about what you use. It's been great to read all the comments with even more recommendations than I have included. I have learned that the note-taking space is a thriving and diverse ecosystem that still has room to grow. As Bruce Lee once said:

> "Adapt what is useful, reject what is useless, and add what is specifically your own."
> &mdash;Bruce Lee