Category: practically-paperless

Welcome to my blog series, “Practically Paperless with Obsidian.” For an overview of this series, please see Episode 0: Series Overview.

I thought I would wrap up this series with a demonstration of how I use Obsidian to manage software projects I work on. In my day job, I make software and manage software projects. Aside from writing code now and then, most of what I do is make notes — notes on requirements, design, procurement, technical notes, lots and lots of meeting notes. Until about 2018 or so, I filled composition book after composition book with these project-related notes. Here is a stack of notebooks from about 2015-2018.

From 2019-2020, I started taking notes on computer, using Mathematica (believe it or not!) because I liked their self-contained Jupyter-style notebooks. When I moved to Obsidian in January 2021, I started keeping my project notes there and have been doing so ever since.

Theory of project management: Keep it simple

I am not a project manager by training. I sort of fell into the role from the work I’d done on software. It turned out that I had a skill for managing projects–or so I have been told. Over the decades I have taken a few courses in project management. Most of the books I’ve read on project management have been worthless. But there have been three books that heavily influenced how I manage projects today; they are not, strictly speaking, project management book, but they are the best books on project management I’ve ever read.

Project management courses I’ve taken and those books that are about project management that I have read focus on things like budgets and schedules, Gaant charts, and requirements, and all kinds of tools and services that you can use to manage your project. What most impressed me about the unconventional books I’ve read on project management–those linked to above that are not strictly speaking about project management–is that (a) they focus on the practical aspects of managing projects; and (b) they are about great big projects that were carried off before all of our fancy tools and services existed.

Indeed, it seems to me that the primary tool of the best project managers is the notes that they take, in whatever form they collect them.

So my theory of project management attempts to keep things simple:

1. Take good notes
2. Link them appropriately
3. Be able to find what you need quickly

This has served me well. Just as the pandemic started, in January 2020, I began a big software project involving lots of departments and dozens of people. Because of them pandemic, the entire project–which lasted about 16 months–was done remotely. We never had an in-person meeting, from our kickoff meeting, through 33 requirements meetings, dozens of design meetings, countless hours of co-programming sessions, testing, product demontrations, training sessions, rollout, and post-rollout support. I started the project a year before I started using Obsidian, but as soon as Obsidian began working for me, I moved all of my project notes into Obsidian and it made things much easier for me.

My ingredients for managing projects in Obsidian

Here are the ingredients that make it possible for me to manage projects in Obsidian. I’ll go into each of these in a little more detail below.

• A template for meeting notes
• A template for technical notes
• A note that I use as a map of content (MOC) for the entire project
• Templater plug-in
• Quick Add plug-in
• Dataview plug-in

Template for meeting notes

I have a fairly simple template for meeting notes. It looks as follows:

The template is designed to work with the Templater and Quick Add plug-ins to make it quick and easy to create a new project-related note. The “project” line in the metadata section presents me with a list of my currently active projects so that I can select the project in question.

You may note that Project is listed twice, once in the frontmatter and once below. The second listing is so that I can link directly to the project MOC. This link is a kind of backup in case something goes wrong with the dataview plug-in and I still want to see the relationships between my notes.

Below is an example of what a completed meeting note looks like:

Template for technical notes

In addition to a template for meetings (and calls) I have a template for technical notes. This one is a lot simpler, and just allows me to create a hard link to the project to which the technical note is related. Here is what the template looks like:

These technical notes can be anything. They can be fleeting notes that I’ve jotted down when trying to optimize some code. They can be my notes on a review of some documentation. They can be a simple outline of tasks I have to try to complete that week, or an outline for a briefing that I have to give.

Plug-ins

I make heavy use of the following plug-ins to speed up the creation of my project notes:

• Templater plug-in
• Quick Add plug-in
• Dataview plug-in

For the first two, I use them almost identically to how I use them to manage my writing in Obsidian. Rather than be repetitive here, I’d urge you to check out Episode 25 where I go into great detail on how I configure templates to work with the templater and quick-add plug-ins.

Tying the project together: My project map of content

It is helpful as a project manager to have all of the information I need at hand. I do this in Obsidian by creating a single map of content note for each of my projects. I follow the same format for each of my project MOC notes. Here is an example of a project MOC from a project I am actively working:

Here are the sections that make up this MOC keyed to the numbers in red in the image above:

1. Frontmatter: this is used to aggregate all of my projects at a 50,000 foot view so I can see the status of everything at a glance.
2. Administrative: this section contains links to administrative information: charge codes for projects, status reports for our project management office, etc.
3. Project documents: links to any documents produced for the project. Here you can see links that point to documents on Confluence, as well as Excel (on Office 365) and a PDF (also on Office 365).
4. Presentations: I end up giving lots of presentations over the life of a project, and I link them all in this section. I’ve lost track of the number of times that someone can’t make a meeting, but asks for the presentation later. This makes it easy to find.
5. Meetings: this is a dataview that lists all of my meeting/call notes. It lists them in order from newest to oldest, along with the title of the meeting or call (which also links to that note in Obsidian) and finally, what type it was, a meeting or a call.
6. Technical Notes: You can’t see it in this view, but below the Meeting Notes section is a section called “Technical Notes” which is another dataview that lists all of my technical notes related to the project, in the same order as the meeting notes.

Other Tools

As far as notes go, this shows pretty much everything I use for managing the project. But it isn’t the entire picture. We use Jira to create tasks and track the tasks in sprints and releases. I have created macros that makes it easy to convert my Obsidian markdown to Jira markdown. I also frequently link to Jira issues in my Obsidian notes. Ultimately, everything is tied together, and I can find what I need quickly.

Envoi

That is, as they say, a wrap. I want to thank everyone who has read and commented on these posts over the last nine months. I hope that folks have found them useful. The series isn’t going anywhere, and will be here on the blog for people to reference for the foreseeable future.

I will be here, too, although I will be writing about other things. You can stick around for that if you want, but I understand if you were just here for the series. In the free time I have now that the series is completed, I plan on getting back into some fiction writing, which I used to do quite a bit of, until I had a bout of writer’s block. That block seems to finally have passed, and I’ve nearly completed the first draft of a new story–my first in more than five years. The first draft was written in a notebook, but the next draft will be written in Obsidian, of course.

Prev: Episode 29: Filling Out Forms

Written on May 23, 2022.

Welcome to my blog series, “Practically Paperless with Obsidian.” For an overview of this series, please see Episode 0: Series Overview.

It sometimes seems to me that most of the paper I deal with day-to-day are forms. I find this ironic. Given that so much of what we do is online, it seems almost archaic to fill out paper forms. And yet, that is what I do. I am the form-filler-outer in the family. If there is a form that needs to be filled out, it ends up on my desk. Kelly says this is because she is bad at filling out forms, but I like to think it is because I am fairly efficient about it. After all, I’ve filled out enough of them.

Obsidian is part of the reason I have become efficient filling out forms. By combining a number of its basic features, I’ve made it easy for myself to have all of the information I need at my fingertips when completing a form.

Family notes

The vast majority of the forms I have to fill out are for a specific person. School forms are for a specific student. Camp forms are for a camper, sports and other activities are for the participant in question. Then there are medical forms for the patient, insurance forms are for the insured, etc., etc.

The foundation of my system for filling out forms starts with a note for each member of the family (the only people I really ever have to fill out forms for). Each of these notes contains the most common information I’d need if I was filling out a form for the person in question.

Below is an example. I took an actual note as a model, but replaced the information with made-up data. You should get the idea:

In addition to the two sections shown above, the family notes also contains three sections containing medical information, school information, and emergency contact information. These sections make use of Obsidian’s embedded note functionality, pulling the information from supporting notes.

Supporting notes

In order to keep information up-to-date, I try to keep it centralized. I keep several notes for this purpose. These notes include:

• Family doctors
• Covid vaccination records
• Other notes with contact information

Within Obsidian, you can embed the contents of one note within another by adding a note link and prefacing it with a ! symbol. In addition, you can include the content of a particular section of a note by referencing just the section in the note link.

Within my Family Doctors note, for instance, I have a section for each doctor that we use. The section contains the doctor’s name, and then contact information for the doctor.

In the Covid vaccination records note, I have a section for each family member, and within that section, a table that lists the vaccinations and dates for each person.

Finally, I have other contact notes (people notes) with sections titled “Contact Info” that are used for emergency contacts. By using embedded links to these notes within my family person notes, I always have the most recent information in each of the family notes when I use them to fill out forms.

Embedding common information

Here is what the embedded sections look like in my fictional note:

Now, here is what the source for the family member note looks like for each of these sections:

Note the highlighted links are embedded links to other notes. That means that I only have to update information in the source notes for it to be reflected in any notes in which they are embedded. It saves me from hunting down every reference to these notes.

Filling out forms

When it comes time to fill out a form, I go through the following steps:

1. Pull up the family member note for the person in question.
2. Use the information in the note to fill out the form.
3. If there is any information on the form that I couldn’t get from the family note, I’ll note it down (usually as a task in my daily notes) as something to add for the next time I have to fill out a form.
4. When the form is filled out, I’ll scan it, add it to Obsidian, and note that I completed a form for whatever purpose in my daily notes for the day, with a link to the scanned document for reference.

Filling out forms shouldn’t be this hard. Indeed, this seems like the perfect task for A.I. to handle. Instead of focusing on identifying images in photos, or writing blog posts for people, I wish that A.I. focused on more practical tasks like filling out forms. For now, however, Obsidian helps me manage the information I need to fill out forms so that I don’t have to go hunting all over the place to find it.

In two weeks, I’ll post the final episode of my Practically Paperless series. The final episode will be on how I use Obsidian to manage projects. Why the final episode? It was never my intention for this series to go in forever. My focus was on finding practical ways of using Obsidian to go paperless. My original outline for the series had 20 episodes. As I wrote those episodes, I outlined 10 additional episodes. I’m ready to write about other things now and continue using Obsidian to be practically paperless. I’ll see you back here on May 24 for Episode 30.

Prev: Episode 28: Archiving in Obsidian: A Tour of My Digital Scrapbook
Next: Episode 30: Managing Projects in Obsidian (coming May 24, 2022)

Written on May 9, 2022.

Welcome to my blog series, “Practically Paperless with Obsidian.” For an overview of this series, please see Episode 0: Series Overview.

Recently, while browing around and older server, I unearthed some digital treasure. I found text files going back to 1994 containing about 100,000 words of my writing. Some of it was old journals, some of it what I discovered were proto-blog posts from an era before blogs existed. All of it I had assumed lost, until I came upon it by accident.

The experience was exhilarating. I was delighted to find this writing, and immediately pulled it into my Obsidian archive folders. (Conveniently, it was already all plain text files.) But the experience reminded me of something that I started to do in my Evernote days, and never quite finished: archive old papers and create a kind of digital scrapbook to illustrate the progress of my output over time.

In my Evernote days, I focused primarily on creating digital scrapbooks of my kids’ work. The old files I uncovered reminded me that I wanted to do something similar with my own papers. I started that process shortly after I made my discovery. What I present today, therefore, is a work-in-progress. You are seeing it in its early stages, as I try to figure out how to organize and present the information. Much is likely to change over time.

Practical archiving

I have in my house several good-sized bins of papers going back to my birth. My mom kept all of this stuff, and after their most recent move, several years ago, sent me what she had collected over the years. The boxes contain everything from birth announcements to report cards to school work to drafts of stories that I would eventually sell. They contain artwork I did, scrapbooks I kept, newspaper clippings (as when I had something printed in the New York Times) and letters I’d written and received.

Ten years ago, I would have tried to archive it all, scanning it all into Evernote and then attempting to figure out how best to present it so that I could find it. That it never happened is due entirely to the scope. There are hundreds if not thousands of pages to scan. I kept putting off the task as too overwhelming.

Now, however, I am taking a different approach. Instead of trying to scan in everything, I am capturing what I hope is a representative sample of papers from throughout my life. I’m trying to avoid duplication where I can. I don’t need every piece of artwork, but maybe one or two every few years to show how my artwork changed. I don’t need every report card, or school assignment, just enough to put together a reasonable picture.

Identifying what to archive

In order to take this more practical approach, I had to figure out what to archive. After some thought, I settled on a kind of “phases of my life” approach:

• Birth – 1979 (when I lived in New Jersey)
• 1979 – 1983 (when I lived in New England)
• 1983 – 1987 (when I lived in L.A. through junior high school)
• 1987 – 1990 (high school)
• 1990 – 1994 (college)

I’d review papers and documents from each of those five periods, taking what I felt was a representative sample, and scan the documents into Obsidian.

Format of archived documents

I began selecting and scanning documents, but I fairly quickly, I realized I needed to make a decision: what format should I scan the documents in? My default is to scan as PDFs. I described my reasons for this way back in Episode 5. But as I scanned in documents and started to create the frame work of a digital scrapbook, it seemed to me that image files were better for the scrapbook purpose than PDFs.

There is a clear tradeoff here. As I mention in Episode 5, I scan PDFs as “searchable” PDFs with the idea that once a plug-in is developed to search PDFs in Obsidian, any PDFs that I have stored will already be searchable. It is not as easy to “search” the content of a image file. But then again, these documents are more of a showcase. I don’t really need to be able to search them the way I need to be able to search other types of notes and documents in Obsidian. I settled, therefore, on scanning these documents as image files.

Within Obsidian, while both PDFs and image files can be embedded within a note, only image files, so far as I know, can be resized, which makes it easier to format the scrapbook the way I want.

Creating a digital scrapbook

When adding the images to Obsidian, I was careful to give them names that would make them relatively easy to find later. I used a “date – subject” format, so if a newspaper clipping appeared on July 7, 1977 for instance, the image file might be named “19770707 – Fireworks.jpg.”

Once I had some documents scanned in, the next step was to figure out the best way of presenting them. When I was doing this for my kids in Evernote, I used a notebook for this purpose. In Obsidian, I decided it could be done with a single note for each person or subject. For my own personal scrapbook, for instance, I created a note and divided into five sections (for each of the five phases described above).

Each major section was labeled with the section name. Within each section, I added subsections with brief descriptions and then embedded images that I collected, sometimes with additional text.

A tour through my digital scrapbook

Below are some examples from my digital scrapbook. Keep in mind I’ve only recently started on this and it is still a work-in-progress. The images below are all from a single note, but I’ve picked out sections to showcase here. In practice, this is just a note in Obsidian that I scroll through to browse, like flipping the pages of a real scrapbook.

Why collect this stuff?

The main reason is because it interests me. I’m fascinated by looking at how I started out and where I’ve gotten to. I like seeing the mistakes I’ve made and how I’ve learned from them. Some of these papers have also proven helpful with my own kids. If they bring home an assignment that they didn’t do well on, and are disappointed or worried that it is a bad thing, I pull out these papers and show them my own mistakes. That seems to make them feel a lot better.

I’m fortunate that my mom kept all of these papers. I’ve tried to do the same with my kids, although my tendency is to scan their papers in digital form, which makes them all the more accessible for putting them into a digital scrapbook.

Next steps

I’ve only just started to sort through the various papers. I’m mostly interested in getting in stuff I written over the years. I’ve got a lot more that I’ve found and need to wade through to pick and choose what want to include. I also need to play around with how I’ve formatted things. There may be better ways to organize the information. I’ve searched around online and the closest thing I’ve found to what I am trying to do is Stephen Wolfram’s scrapbook.

In Evernote, I’d started digital scrapbooks for my kids, so I am also in the process of moving those scrapbooks into Obsidian. I think it will be fun for them to be able to scroll through their scrapbooks as they get older.

Prev: Episode 27: Use Case: Journal Writing in Obsidian
Next: Episode 29: Filling Out Forms

Written on April 25, 2022.

Welcome to my blog series, “Practically Paperless with Obsidian.” For an overview of this series, please see Episode 0: Series Overview.

For those just joining us, one of the things I have been trying to do is to use Obsidian for all of my writing. In Episode 25 I described how I used Obsidian to manage my “professional” writing. In Episode 26 I showed I I use Obsidian for my blog and social media writing. Besides my professional writing and blog writing, the other major kind of writing I do in for my diary. That is what I’ll discuss in this episode.

Background

I recently passed the 26th anniversary of my diary¹. Those interested can follow that link to see some of the history of my journaling. The short version is that I started fairly late, when I was 24 years old². The bulk of my diaries are on paper.

When I first started using Obsidian, I toyed with keeping my journal there, but eventually gave up and returned to paper. There were two reasons for this. First, was the lure of paper systems. They are simple and reliable. The second was that it seemed to me that I was more likely to write in my journal consistently if it was on paper. When the calendar rolled around to 2022, however, I decided that my logic on the latter point was flawed. After all, I had spend years using paper journals. I should give a digital version a fair shake. So for 2022, I decided, I’d force myself to write my journal in Obsidian. If, at the end of the year, I want to return to paper, fine.

Format of the journal

My paper journals started as big blank books. There was nothing limiting the size of an entry. There were also no pre-printed guides for dates or anything. I’d scribble entries and include the date. Beginning in 1999, I switched to those red At-a-Glance Standard Diary volumes. There is a page for each day of the year, with the date information pre-printed on each page. There were also little markers at the top you could circle to record the weather (sunny, cloudy, etc.). Unlike the blank books, I was limited to what I could write in a day by what fit on the page.

(Image from At-a-Glance)

In 2017, I switched to large Moleskin Art Collection sketchbooks. Once again, I had blank pages and was free to write as much as I wanted. To add structure, however, I began numbering my journal entries. My idea was that the numbering would continue from one volume to the next, rather than restart. That way, I could index my journal based on entry numbers instead of volume/page number. It also meant I could refer to previous entries by their number.

I wanted the best of both worlds in Obsidian. Here is how I got there.

How I setup my journal in Obsidian

1. A template for my journal entries

I started with a template which has some meta-data in it like the templates I demonstrated in the previous two episodes.

I don’t tag the vast majority of my journal entries, but occasionally I will. For example, if I am writing a journal entry while traveling, and about my experience, I will tag the entry with a “travel” tag.

The “note-type” is relatively new. I’ve gone back and added this to my other templates. It allows a quick way of searching for notes of a particular type, for example, diary entries, story submissions, blog posts, etc.

The entry date and time are self-explanatory and used in dataviews for sorting and filtering on dates.

As I mentioned, those Standard Diaries I used to use had a template at the top of each page to note the weather. I added a weather line to my journal entry template, and then added a custom function in Templater to fill in the current weather based on my current location. See the “Templater + QuickAdd Plug-in” section below.

The part of the template marked “Dateline” serves two purposes:

1. I wanted a way to easily see the date of an entry. I like how the date appeared at the top of each page in the Standard Diary, so I used a callout in Obsidian to emulate this.
2. The dateline is also a link to the daily note for the date in question. That way, the diary entry automatically shows up in the backlinks of the daily note for that day.

2. One note per entry

I like my method of having a unique index number for each diary entry. Some entries are general and might cover an entire day. Other times, I’ll have multiple entries on the same day, some of them topical, others more general. The entry number allows my entries to be atomic in nature, if I want them to me. It serves as an index number to an entry and makes it easy to link to a specific entries from other places.

In Obsidian, I just continued the numbering from where I left off in my Moleskine notebooks. The filename of the entry is simply the index number. This is convenient because I can then use the QuickAdd plug-in functionality to automatically increment the entry number upon creation of a new entry.

3. Templater + QuickAdd Plug-in for creating new entries

In Episodes 25 and 26, I said that I used the Templater and QuickAdd plug-ins. As I demonstrated above, my template makes use of Templater substitutions. It also makes use of a custom function for getting the weather. Here is what that function looks like within Templater:

Here is an example of an entry including the weather:

For creating the new journal entry, I use the QuickAdd plug-in. For the New Diary Entry it is configured as follows:

The result of all of this is when I create a new diary entry, I can immediately begin typing and the entry is already properly filed, includes the date, time, and weather. I can type as much or as little as I want, giving me the best of both the templated Standard Diaries and the blank Moleskine sketchbooks.

Linking my journal

One advantage that immediately became obvious when I started keeping my journal in Obsidian was my ability to link to and from the journal. I mentioned how the dateline in my template ensures that entries show up in the backlinks of my daily notes, like this, for instance:

In addition, I will sometimes link to specific entries from within my daily notes when I want to provide more context to the line item in the notes. This goes along with my desire to make my daily notes an index for my life. Here is an example of that from back in early April:

Then, too, within my journal, I sometimes link to other notes to make connections and provide context. There are a couple of ways I do this:

• When writing about a noteable event involving someone in the family, I will link to my note for that person. This causes the particular journal entry to show up in the backlinks of the note for the person in question. For example:

• When writing on a specific topic, I will sometimes link to another note on the topic. If I am writing about a book I am currently reading, I’ll link to my source note for the book, for instance.

Privacy concerns

I imagine the question might arise as to whether I have any privacy concerns about keeping my journal in Obsidian. The short answer is: no, I don’t. For a longer, more detaied answer, see Episode 23: Protecting My Data in Obsidian.

Typing versus handwriting

I learned to keep a journal on paper, so I have a natural bias toward paper journals. I also like using a fountain pen I acquired for my birthday a little over a year ago for this purpose. However, I’ve committed to keeping my 2022 journal in Obsidian for duration of the year. There are some advantages and disadvantages that I have discovered so far.

Advantages

• I can type fast and because of this I tend to write longer journal entries in Obsidian than I would write in a paper journal longhand, frequently adding more detail.
• The ability to quickly find something in my journal through a search is a big plus. I use a search that focuses on the path where my journal entries reside to cancel out noise from other sources.
• Being able to link journal entries to other notes is also a plus

Disadvantages

• For reasons I can’t fully understand, I am not nearly as consistent about my journal writing in Obsidian as I am when using a paper journal. Perhaps it is the distinctness of the act: I pull the journal off the shelf, set it on my desk, open it to the current page, unscrew the cap of my fountain pen, and begin writing. It is a unique ritual in my day. On the other hand, creating a note in Obsidian is something I do countless times each day, and making a journal entry is one of those times. There is nothing distinct about it.
• I miss the physical act of handwriting. My journal was one of the few places where I still wrote in cursive³and I enjoyed the flow of that.
• Paper still feels like a more permanent storage medium than digital storage.

This last point serves as a nice transition to next week’s topic. As I wrote yesterday, I recently uncovered some digital treasure–files and writing I’d done from nearly 30 years ago. Some of that I’ve pulled into my archive in Obsidian. This archive serves as a kind of digital scrapbook for me, and so I thought I’d give a tour of my Obsidian archive next week to illustrate the kinds of things that get stored there.

See you back here next week.

Prev: Episode 26: Use Case: Managing My Blog Writing in Obsidian
Next: Episode 28: Archiving in Obsidian: A Tour Through My Digital Scrapbook

Written on April 16-17, 2022.

Welcome to my blog series, “Practically Paperless with Obsidian.” For an overview of this series, please see Episode 0: Series Overview.

One of the things I have always loved about plain text files is that they are easy to manipulate. More than fifty years of effort has gone into reliable methods for parsing text from text files. It is for that reason that for a long time, I maintained my list of books I’ve read since 1996 as a plain text file with markdown¹, and wrote scripts to pull all kinds of data from that file. Other people know this, and Obsidian has a rich community of plug-in developers. It should be no surprise, therefore, that someone came up with a plug-in that allows you to query data from plain text files. Lately, I have been experimenting with the Dataview plug-in, looking for practical uses for querying my notes.

Before jumping into my experiments, I wanted to point out that there is quite a bit of discussion about plug-ins in the Obsidian community and if and how they make the overall system less future-proof. There are good arguments on both sides. Not long ago, I made a post to the Obsidian Reddit group on this subject, outlining my thoughts. Briefly, I found a balance that I am comfortable with and I have no problem using plug-ins like the data tool. Your mileage (and requirements) may vary. There are lots of good opinions. You can find some of them in that Reddit thread.

One thing I really like about the Dataview plug-in is that it is familiar. As a software developer, I’ve worked with dozens of programming languages over the years, but alongside almost all of them was SQL, and the Dataview’s query language is very similar to SQL, which make it easy to learn. The harder part was figuring out practical uses for the dataview. After experimenting for a while to get the hang of things, I came up with a couple of criteria to help identify practical uses for the Dataview tool, over say, a embedded search query. Here are a few of those criteria:

1. Use to access or summarize frequently-accessed data.
2. Use in situations where the data is dynamic, and can change over time.
3. Use to help automating a process

With those criteria in mind, I’ve managed so far to find three places to make use of the dataview plug-in that provide me with practical, everyday use.

1. A Plain-Text Address Book

I have a top-level folder called People, and under that folder, I have a note for any person that I interact with on a regular basis. These notes serve two purposes:

1. YAML frontmatter in each note allows me to capture “address book” information about the person in question so that I have that information at my fingertips. Sure, it duplicates some of what I have in the Contacts app, but again, this is plain text and I consider it my “authoritative” source for this information.
2. The note itself serves as a place to link to when I mention the person elsewhere in my notes. The mention might be in a daily note, or journal, or some other note. By using a link to the person-note in my daily notes and other notes, I can see everywhere that person was mentioned by looking at the backlinks of the person note itself.

Now, I can open up the People folder and scan down the list of notes there, all titled in “Last, First Name” format, but all I can see are the names of the people. No other information. I have to click on a note to see a person’s phone number or email address, or birthday. What I needed was a dynamic index, and that seemed to me to be the perfect use case for the Dataview plug-in.

I created an “Address Book” note and in that note, I included the following Dataview query:

This generates a nice table of all of the notes under the People folder, displaying the name of the person (as a link to the note), along with their email, phone, and birthday. (Note: for the purposes of this post, I copied my People folder and then used a fictional name and contact info for each person to make things easy on me.)

When I change information in an individual note, it is automatically updated in the table when I look at the table. And from the table, I can easily locate a person and contact information. I’m sure this isn’t unique. I’d guess that this is one of the first practical ways that many people make use of the dataview plug-in.

2. A Dynamic Idea List for the Blog

Those who follow this blog for more than just my Obsidian posts know that I write about just about anything that comes to mind. I’ve got more than 7,000 posts going back more than 16 years now. Last year, I had a goal for publishing a post every day. This year, my goal was expanded to continue to publish a post every day, but to write two posts every day. That allows me to build up a backlog. But it also means I need a useful way to collect ideas to write about.

Typically what I do is jot ideas down in the Field Notes notebook that I carry with me everywhere I go. Later I transfer them into my daily notes. Or, if I happen to be sitting at the computer, the ideas go directly into my daily notes. The ideas go in the following format:

Since the format is consistent, this also lends itself to query that allows me to look for note ideas I haven’t yet written. Looking at how the Dataview queries work, I began to think of this query as “any task in my daily notes tagged with ‘post-idea’ that isn’t yet completed.” I experimented this with a straight dataview query, but I couldn’t quite get it to work the way I wanted, mainly because I couldn’t figure out how, from a TASK query, to filter out things by tag. Instead, I used a dataviewjs query. I created a note called “Post ideas” and then added the following dataviewjs query:

What the query does is it looks for all notes tagged with “#post-idea” where the text of the task also contains the tag “#post-idea” and the task is not yet completed. The results look like this:

There are several things I really like about this:

1. Because the ideas go in my daily notes, and the task query renders the name of the file that the task appears in, I not only get a list of un-used ideas, but I can also see how old they are beacuse they are listed under the daily note in which they were added.
2. I have one place to go to get a list of ideas to write about.
3. Once I finish writing a post, I click the checkbox on the task and it immediately drops out of the “not yet written” section of the Post ideas file and moves into the “Completed” section of the file.
4. If I don’t end up using an idea (I don’t use all of them, just the good ones), I’ll cross it out.

3. A Summary MOC for Services and Subscriptions

In Episode 18, I wrote about how I kept a folder with a note for each service or subscription we have. The YAML frontmatter contains information about the subscription/service like the monthly and annual cost, renewal date, etc. In addition, I use those notes to document any interactions I have with the service provider, so that all of the information related to the service is in one place and easy to find.

One use I found for the dataview plugin was to summarize all of these services in table form. This provides a nice summary index of all of the services and subscriptions we have that are currently active. If a new one is added, it automatically appears in the summary. If one is canceled, it drops off the summary list.

The note contains the following dataview query:

and the resulting table looks as follows:

This makes it easy to find everything we subscribe to. I can jump to a service by clicking on a note link to get more detail about the service.

I am still experimenting with the dataview plug-in, but these are a few of the practical uses that I have found, and that I use on a regular basis. Their dynamic nature provides simple automation that saves me a fair amount of time across several types of tasks that I perform several times each day.

In next week’s post, I’ll have something to say about tags and tag taxonomy, something I’ve struggled with since my early days using Evernote. See you back here next week.

Prev: Episode 19: Archiving Notes
Next: Episode 21: Tagging Notes: A Decade-Long Struggle

Written on February 27-28, 2022.

Welcome to my blog series, “Practically Paperless with Obsidian.” For an overview of this series, please see Episode 0: Series Overview.

Why bother archiving notes?

During the years I used Evernote, I accumulated more than 12,000 notes, most of them still sitting in my Evernote notesbooks to this day. My goal then was to see if a paperless lifestyle was really possible, so everything went into Evernote. Over time, this resulted in some interesting observations:

• Of the 12,000 notes I put into Evernote, between 100-200 were notes that I used on a regular basis (that’s about 0.8 – 1.6%)
• Another 100-200 notes were notes that I used periodically, usually annually, but sometimes more frequently.
• The rest of the notes I almost never touched or even looked at. That means I collected around 11,500 notes (96% of all the notes) that I never put to any use.

This created some unexpected problems:

1. It takes time to get a note into Evernote, whether dragging a PDF onto a note, scanning a document, or setting up some automation to get a note into the system. I was scanning in documents that I was never looking at again. That’s a waste of time.
2. I had a process for processing a note — tagging it, updating its create date to reflect the document date, etc. I did this for every note I put in Evernote. But again, since I actually only used less than 2% of the notes I put in, this was also a waste of time.
3. The notes, having been captured in Evernote, and parsed by Evernote’s search system to make the notes searchable, added a lot of noise to my searches. That is, these notes that I never used and never looked at would show up in search results because of some keyword in the document or note somewhere. This impeded the process of finding notes that I was looking for.

Evernote did not have a particularly good mechanism for identifying notes to archive. Ideally, what I would have liked to do is a search for all notes that were not viewed in a given period of time. Alas, while Evernote has the concept of a “create date” and an “updated date” for a note, it does not have a concept for “last viewed on” date. That made archiving tricky–too tricky for me to waste time trying it on the volume that I had to deal with.

As I began to migrate from Evernote to Obsidian, I had these problems in mind, and I was determined not to fall into the same trap with Obsidian.

One way to do this was to reframe my original goal with Evernote. There, I was experimenting to see if completely paperless lifestyle was possible. It was, but it generated a lot of unnecessary notes and noise. When I began using Obsidian, I asked myself, what would a paperless lifestyle look like in a practical sense, as opposed to an extreme? A few ideas came to mind:

• my notes would be working notes in that they contributed in some practical way to my day-to-day work and life.
• some of these notes might be part of an historical record, even though they might not be used every day (think: older daily notes, journals, etc.)
• some of these notes would be “permanent notes” in the Zettelkasten way, and while I might not access them everyday, they would become part of a useful personal knowledge system.

Perhaps most important: I needed a mechanism for keeping my notes “working notes.” I needed a way to review my notes and archive ones that are no longer active.

Retiring notes

First, what does it mean to archive? For me, archiving a note is a way of taking it out of active duty without losing it entirely. I think of it as “retiring” a note. A note or set of notes contains accumulated knowledge. That knowledge may no longer been needed on a day-to-day basis. It woudl be useful to have a way of archiving those notes so that they didn’t clutter up searches.

The framework I’ve evolved (through much trial and error) for organizing my notes provided a clue for how I might retire notes, and get them out of the way without losing them. Recall from Episode 18, that within Obsidian, the vast majority of my notes end up in one of three folders: _attachments, _documents, and _slipbox. The rest of my organization is hierarchy to maps of content (MOC) notes that provide context and links to the notes in those three folders

To that framework, I have added a new folder, which I call _archive. Notes that are ready to be retired can be moved into this folder. By having all of my retired notes in a single folder, I can use Obsidian’s query language to exclude anything in that folder from a search. For instance, if I was searching for all notes tagged with “taxes” and only wanted my “active” notes (that is, notes that are not retired), I could run the following query:

The first part of the query is important. As you can see in the search explanation, I am deliberately excluding anything in the _archive folder. This takes care of the noise problem I had in Evernote. For common searches, you can imagine setting up saved searches each of which is prefaced with that exclusion pattern.

This nice thing about this is that the notes don’t really go away:

1. They are right there in the _archive folder should I happen to need them.
2. I can still surface them in searches them by leaving off the path exclusion.
3. Because I move them into the _archive folder, any links to the notes are automatically updated by Obsidian.

Identifying notes to retire

Unopened notes

For me, this is the tricky part. I’d prefer a hard-and-fast rule. MacOS and Linux, for instance, can track when a file was last opened, which is different from when it was last updated. This is an important distinction. Once a note is in place, it often doesn’t change. The only empirical way I can tell if I looked at is to look at the last opened date on the file.

The problem is that Obsidian (on MacOS, at least) does not seem to update the last opened date of a note when the note is opened in Obsidian. I think this is worth a feature request and I made such a request on the forums recently. Other MacOS apps will update the “last opened” date when the file is opened. For instance, a PDF opened in the Preview app will update the last opened date on a note, but viewing that same PDF in Obsidian does not update that date.

The reason that date is important is because it would allow me to setup a query, at the very least at the OS level, to find all notes that have not been opened in more than, say, one year. These would be good candidates for retirement.

Of course, that is first cut, and fairly liberal. A more conservative search might be all notes that are not in my _slipbox folder that have not been opened in more than one year. Over time, that query could be refined. Periodically, I could move any matches to the _archive folder.

Manual review

Short of that, a manual review would be required. Fortunately, because my goal for Obsidian is different than Evernote (practically paperless, remember?) I don’t put nearly as many notes into Obsidian as I do Evernote. I keep the practical stuff in Obsidian. That means in the first 14 months that I’ve been using Obsidian, I’ve accumulated just 900 notes — and even some of those are probably worthy of review and culling.

There are a few things that can help this manual review. One is look for notes that haven’t been updated in more than a year. That provides something to look at, but it is not as good as being able to look at notes that haven’t been opened in more than a year.

Regardless of how I end up identifying notes to retire, the process, once identified is pretty simple:

1. Add a YAML frontmatter key to the note to indicate which folder the note was originally located. This extra step makes it easy to put the note back in the right place if it ever needs to come out of retirement.
2. Move the note into the _archive folder.

Not everyone needs to, or wants to archive their notes. My experience shows that, for me, this is useful to keep my notes in working order, and to avoid clutter. It was something I thought about as I began bringing my notes over from Evernote. I haven’t yet started to archive notes in Obsidian, but I have a framework in place for when I am ready to do so.

Next time, in Episode 20, I’ll discuss how I’ve been experimenting and making use of the Dataview plug-in. See you back here in a week!

Prev: Episode 18: How I Organize My Notes
Next: Episode 20: Experimenting with the Dataview Plugin

Written on February 21, 2022.