1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
#+date: <2022-03-02>
#+title: Easy, Reliable Note-Taking
#+description:
#+slug: reliable-notes
* Choosing Durable File Formats
:PROPERTIES:
:CUSTOM_ID: choosing-durable-file-formats
:END:
#+begin_quote
TL;DR: Write in a format that can be easily rendered and read in
plain-text mode (e.g., =.txt=, =.md=, etc.).
#+end_quote
As I've written more and more over the years, I've found that my love of
note-taking is always growing. Everything I learn or need to remember
can be written down in a note and saved digitally, with no cost to
myself. Unlike paper copies that need physical storage space, digital
files simply need space on your local disk or cloud storage, which is
fairly abundant these days.
However, I had a historical struggle with migration of notes between
different apps that require different formats and applied proprietary
styling. This meant that I had to go through each note during migration
and edit the file to look presentable again.
For the last year or two, I have written everything exclusively in
[[https://en.wikipedia.org/wiki/Markdown][Markdown]] format. Small
notes, long-form writings, and even these blog posts are all written in
Markdown.
Why Markdown? While I do appreciate the simplicity of plain-text files
without any formatting, I often need visual cues such as heading and
code blocks to keep my thoughts straight. Markdown provides a minimal
set of styling indicators for me to style my notes without adding any
proprietary, embedded data into the files. If I want a top-level
heading, I simply add a hash (=#=) before the line. An added bonus is
that even if a system doesn't understand Markdown, it will render it as
plain-text and I can read it just as easily.
For example, here's how TextEdit on macOS will open and display a
Markdown file in plain-text, since it does contain any features to
preview Markdown as HTML:
#+caption: Plain Text Markdown
[[https://raw.githubusercontent.com/ccleberg/img/refs/heads/main/blog/20220302-easy-reliable-note-taking/plain_markdown.png]]
** Saving & Syncing Files
:PROPERTIES:
:CUSTOM_ID: saving-syncing-files
:END:
In order to read and edit my notes across platforms, I use my personal
cloud storage through Tresorit due to its native integration with macOS
and iOS file managers. In addition, Tresorit works well on Debian-based
Linux distros, which I used before macOS (and will likely switch back to
in a few years).
You can use whatever sync software you want - syncing plain-text or
markdown files is incredibly easy and fast, since the files are
generally tiny.
Since the cloud storage syncs files automatically, there is no need for
me to sync anything manually or kick-off a sync job to update my files.
This means that I can edit on mobile, and it takes about 5-10 seconds to
see the changes on desktop.
*** Version Control with Git
:PROPERTIES:
:CUSTOM_ID: version-control-with-git
:END:
A different approach I've contemplated is storing my notes and
attachments is using a hosted Git repository to track changes to the
files. However, I don't want to rely on an external service that could
potentially see into my data, even if the repository is private.
I might just do =git init= locally and then commit my changes each time
I write or update a note, but that seems to be a lot of work just for
tracking changes - which I don't necessarily care to know.
*** Backups!
:PROPERTIES:
:CUSTOM_ID: backups
:END:
One small addition to the storage/sync conversation is the idea of
backups. Personally, I manually create periodic backups of my entire
cloud storage, compress it into an archive, and store it on my home
server.
To improve my workflow, I am going to be exploring options to
automatically compress the mounted cloud directory and send it over to
my server on a set schedule.
** Writing on Desktop
:PROPERTIES:
:CUSTOM_ID: writing-on-desktop
:END:
#+begin_quote
*Update (06.14.22)*: Since writing this post, I have reverted to simply
keeping my =notes= folder open and opening notes individually in
TextEdit for a more minimal and relaxing writing experience on the
desktop.
#+end_quote
The bulk of my writing occurs in a desktop environment, with a full
keyboard layout and wide screen. I don't illustrate with a smart pen, I
rarely use embedded images, and I love being able to see all of my
notes/directories in a sidebar.
With this simple set of requirements, I chose
[[https://obsidian.md][Obsidian]] as my desktop text editor. Obsidian
has some in-depth tools like a graph view, command palette, mentions,
etc., but I've found that using it as a simple Markdown editor is
incredibly easy and straightforward.
Here's an example of how my Markdown notes look when opened in
plain-text mode:
#+caption: Obsidian Markdown Source Mode
[[https://raw.githubusercontent.com/ccleberg/img/refs/heads/main/blog/20220302-easy-reliable-note-taking/obsidian_source_mode.png]]
Here's the "live preview" version, where the Markdown is rendered into
its HTML format:
#+caption: Obsidian Markdown Live Preview
[[https://raw.githubusercontent.com/ccleberg/img/refs/heads/main/blog/20220302-easy-reliable-note-taking/obsidian_live_preview.png]]
*** Programming on Desktop
:PROPERTIES:
:CUSTOM_ID: programming-on-desktop
:END:
While I was writing this, I realized I should specify that I don't use
the same editor for writing notes and for writing code. For programming
purposes, I use [[https://vscodium.com][VSCodium]] as my development
IDE.
** Writing on Mobile
:PROPERTIES:
:CUSTOM_ID: writing-on-mobile
:END:
Personally, I write very little on mobile, except when needing to take
important notes on-the-go. Any long-form writing, journals, etc. are
done at home, where I always have my laptop available.
I wanted a simple and foolproof editor for iOS, preferably open-source.
After a long journey of testing the few (& terrible) open-source iOS
note-taking apps, I finally found a phenomenal one:
[[https://github.com/simonbs/runestone][Runestone]]. This app is
fantastic for note-taking, has plenty of optional features, and
integrates natively with the iOS file manager.
This app opens the iOS file manager and allows you to click any file you
want, opens it up in an editor, and lets me save and close out of that
note.
Quite simple but effective.
|
