I originally wrote this in my daily journal, but extracted it to a full post.
I’m nearing a point in writing where I need to consider how I might more easily
publish elements of my personal journal, while maintaining some as “too
private.” This is a significant deviation from my blogs current setup. Much to
consider, but what I have works, albeit with “friction”; a topic of the first
2025 IndieWeb Carnival “On the importance of friction”.
I’m smiling as I’m leaning into the robustness of the elfeed package 📖
.
Re-Introducing Elfeed
First, I have an RSS 📖
feed reader. In which the “news” rolls in according to
when it was published, not some capturing algorithm.
Second, as I encounter interesting links by feed entries, I can open them in
Emacs Web Wowser (EWW 📖)
. From there, I give it a read and if I like the general disposition, I can
invoke eww-copy-alternate-url to see if there are alternate URLs (e.g. an RSS
feed). And add that to my list of feeds.
Third, as I read and want to comment, I invoke org-store-link which will copy
the entry’s URL and title. I start capturing my thoughts and invoke
org-insert-link to past the feed entry and title. This link type is elfeed.
Meaning when I click on the link, I’m taken to the cached elfeed package
version of that
entry.
Fourth, I extended my elfeed package
link type export from Org-Mode 📖
to export the URL of
the feed item. Thus when I render my notes as HTML 📖
, the elfeed package
link types are
transformed to the well-known http://… format. I wrote about this feature in
Exporting Org Mode Elfeed Links.
Fifth, is the local cache/database of elfeed package
entries. All of those feed entries
that have scrolled through my reader. Those, in their full text, are stored
locally.
(Sidenote:
Writing this, I wish I would’ve started using elfeed package
many years ago. But
alas, those posts are lost to the ether.)
They are available for offline reading, even years past having read them. And
I’ve treated these as important artifacts for me to “preserve.” And by that I
mean, make sure I have regular back-up copies of that information.
Let’s review that process:
- Generate an occasional copy of the cache.
- Copy that copy to a few different devices.
Generate an Occasional Copy of the Cache
I have the following Emacs 📖
code, which is available on Github):
(defun jf/syncthing-aling ()
"Synchronize files into SyncThing bucket."
(interactive)
;; Ensure we have our queue and our ready location
(mkdir (file-truename "~/SyncThings/queue") t)
(mkdir (file-truename "~/SyncThings/source") t)
(message "Synchronzing denote files to cloud...")
;; There's a 1 in 10 chance that we'll perform the sync. Toss that d10.
(if (= 0 (random 10))
(progn
(message "Syncing elfeed database...")
;; We tar zip into one directory (our queue) and then move that
;; file in its complete state into the ready directory. As move
;; is instantaneous and we don't need to worry about syncthing
;; picking up a partially completed file.
(shell-command
(concat "tar -cvzf "
(file-truename "~/SyncThings/queue/elfeed.tar.gz")
" " elfeed-db-directory " && mv -f ~/SyncThings/queue/elfeed.tar.gz ~/SyncThings/source&")
"*syncthing-aling*"
"*syncthing-aling*"))
(message "I'll get you next time Gadget")))
;; Based on the idea of habit stacking, whenever I pull down my RSS
;; feed, I'll go ahead and sync my notes.
(advice-add #'jf/elfeed-load-db-and-open :before #'jf/syncthing-aling)
(add-hook 'after-init-hook #'jf/syncthing-aling)
Let’s pull out the comments
(Sidenote:
I made some adjustments to the comments to improve clarity, I hope.)
in the order of operation:
- Based on the idea of habit stacking, whenever I pull down my RSS
feed, I’ll go
ahead and sync my notes; maybe.
- Ensure we have our queue and our ready location.
- There’s a 1 in 10 chance that we’ll perform the sync. Toss that d10.
- We tar and zip into one directory (our queue) and then move that file in its
complete state into the ready directory. As move is instantaneous we won’t
need to worry about SyncThing 📖
picking up a partially completed file.
Key in this is building the back-up process into a daily or thrice-daily ritual
of mine.
I accept that my back-up won’t be “immediately up to date” but in using this
process I can more reliably see when there are errors. That is I’m putting the
“logs” in a place visible during my ritual of reading my RSS
feed.
Copy That Copy to a Few Different Devices
I setup SyncThing
on a few different devices. And the RSS
feed cache is sent to
those devices as “read only.” I don’t want to fuss with multiple devices having
conflicting versions of this canonical cache, hence writing them to the devices.
To restore from those backups, I’d unzip and un-tar the files. As there’s no
“operational urgency” to the backup, I’d restore at my leisure and then document
accordingly. In essence, reverse the process of the Emacs
function.
I’ve set my synchronization rules to only run when the devices are on the same
network.
Conclusion
I feel a contentedness of having a repository of things I’ve read (or at least
gathered) from the Internet. It is something that I should be able to easily
re-build were I to lose or replace my primary machine.
I’ve chosen to use SyncThing
instead of “pushing to the cloud” in part as a
low-stakes experiment on eschewing cloud storage.
Why? This little local archipelago I’m creating requires far less resources
than constantly syncing to a “remote” cloud. And I have more control over how
it’s used as well as how many copies are saved.
I’m also treating this as a small, concrete, yet reversible experiment with
cause for reflection. That is “how might I reduce my cloud storage footprint?”
And adjusting my relationship to “always available” versus “available upon
request.”
And here’s the realization: I don’t need much to always be available. And, with
the current process, there’s space to identify what I want available outside of
a tarball and thus “readable” on one of those other devices.
For example, I’ve shifted my Shopping List to write to that ready directory, not
tarred and zipped, but as a plain text file. Which I can then read on my phone.
There’s more to think (and thus write) about in regards to how I’m thinking
about this SyncThing
ecosystem. But for now having a personal back-up is an
absolute reassuring joy.