my personal note taking journey

Hi, this is Scott, the creator of phonetonote. Today I'll be typing in the first person to share my personal note taking journey. I've used a number of tools for a variety of purposes over the years, and think my previous experiences and workflows provide context for phonetonote's present and future. This post chronicles my journey through these tools and how I use them.

OneNote for the classroom

My journey begins in the summer of 2010. I'm setting up my brand new Dell Laptop in preparation for my first semester as an undergrad student. Fortunately, Microsoft just released OneNote 2010:

via https://www.businessproductivity.com/

I created separate tabs for each of my classes, and was off to the races in the fall. OneNote worked really well for taking notes from my laptop, and even had some quick-capture features way ahead of its time:

A more narrow view designed for split-screen note taking
Right click → new note, from anywhere in Windows 10
Send any document to OneNote's virtual printer (we might try to steal this one)

Simplenote on the go

OneNote worked great to take classroom notes on my Windows laptop, but my needs were quickly changing. I started to attend a lot of meetups and networking events outside the classroom, where I wanted to take notes from my iPhone.

I was also learning Ruby on Rails development, which at the time was difficult to do from Windows, so I had three laptop workflows:

  • Boot the Dell into Windows 10 for academic work
  • Boot the Dell into Ubuntu for personal Rails development
  • Use the Macbook I got from an internship for work Rails development

My developer experience was better on macOS, so I planned on eventually replacing my Dell with a Macbook and converging towards Apple's ecosystem. With that in mind, I found SimpleNote, a light-weight note taking app that worked well on iOS and macOS. SimpleNote was functionally similar to what Apple Notes would end up becoming, but this was a full year before Apple made their apps work cross-OS with Mountain Lion. SimpleNote worked well to quickly capture my fleeting thoughts on mobile. Those notes would sync to my Macbook, where I would "clean up" the notes as best I could about once a week. This worked ok, but I had a feeling of the notes being "lost" or easily forgotten once they were cleaned up. I didn't have a good way to look back and reference previous notes, aside from just scrolling through a linear list. I briefly looked into Evernote to solve this problem, but found it was too cumbersome and slow to get data into consistently. I tend to prefer light-weight, faster tools and would rather adopt my workflows to make them work.

Despite its long-form flaws, SimpleNote worked well enough for it to stick around for a few years. I augmented it with separate task-management tools, and the helpful hand of pen and paper.

Separating Out Tasks

SimpleNote gave me the ability to take notes from anywhere, and with that I found myself writing more reminders and todos to myself. This had a few problems:

  • they were jumbled up in the rest of my notes (remember, SimpleNote didn't have great filtering/tagging)
  • they tended not to be very specific or actionable
  • I had no way to deal with repeating tasks

I had heard good things about Wunderlist, and briefly tried it, but as usual also gravitated towards simpler, lighter-weight tools. I loved the beautiful minimal design of TeuxDeux. Teuxdeux's weekly view is the main inspiration behind RoamJS Weekly Notes, and serves as an inspiration for better time-related ux in future tools for thought.

TeuxDeux weekly view

TeuxDeux was beautiful, but at the time lacked support for repeating tasks. That was one of the three reasons I was searching for task management software in the first place, so I had to move on.

I briefly used a tool that deserves recognition here, but the problem is I can't remember its name. It was either web-based or iOS, and had a simple two-column design. The trick was that at the end of the day, any tasks still to be done would move from the left column, to the right. The idea was that you could start the next day fresh, while those incomplete tasks were still accessible one column away. I think this is noteworthy because it combined notes and time in a way that I wouldn't really think about again until Roam's daily notes. If anyone else remembers this app, I'd love to know.

I ended up landing on Any.do for task management. Its minimal iOS app allowed for quick task creation, categorization and prioritization. I could create repeating tasks, and its web app let me see and arrange my tasks from my laptop.

any.do made it easy to create and reorder tasks

Any.do worked well to augment Simplenote. I could input new tasks as fast as I could before, but it was much easier to organize and prioritize them. Any.do also released a calendar integration that worked relatively well. It would pull in your calendar events and show them alongside your tasks:

tasks and events, together

phonetonote's zapier integration or the RoamJS Google Calendar plugin achieve similar functionality with today's tools for thought, but this was very convenient for its time. These integrations speak to the value of seeing information from different sources together and in the correct context. I'm excited that future tools for thought will be built in a way to enable more of this. More data sources (calendar + rss would be a great start), and more ways for end users to stitch them together.

Analog Help

Simplenote and Any.do worked well together, but I further supplemented these digital tools with some analog ones. I keep a pocket size notebook (first moleskine, now Field Notes) and pen nearby for capturing fleeting thoughts and quick tasks.

I have larger notebooks for sketching new ideas, drawing technical diagrams, and writing pseudocode. The larger notebook gives me room to create annotations around original sketches. These become ad-hoc task management systems when deep in flow, which tends to happen as I'm transforming a sketch into code.

And lastly, I've found I operate best when a large whiteboard is nearby. I've found no better way to iterate on complex system designs.

Google Docs Stopgap

My combination of Simplenote, Any.do and lots of notebooks served me relatively well as I finished my undergraduate studies. After moving from Windows to macOS, I replaced OneNote with Google Docs. Google Docs served its purpose for long-form notes well enough, but I disliked how it dealt with indents and bullets, and how it wasn't markdown compatible. I also had to manually move notes from Simplenote into a Google Doc. And I couldn't reference Google Doc notes in my Simplenotes.

Things didn't work well together, but at least I had a handful of tools I could use for different purposes.

Into the Workforce with Bear

I kept the same set of tools as I transitioned from studying to writing software for a living. It worked for a bit, but I started to see some signs of weakness as I applied these tools to new use cases:

  • Simplenote nor Google Docs had good support for code blocks, which I wanted more of as I started writing more technical documents
  • I could create different documents or notes for different people, but tracking dependencies or ideas between the documents became cumbersome

The straw that broke my old stack's back was Simplenote crashing when I dragged it from my laptop display to my external monitor, which I did at least once a day. This is a bit unfortunate, as the issue ended up being a macOS SDK bug, but nonetheless my workflow was broken and I began searching for new tools.

I found Bear.app and immediately liked it. It worked better for me than Google Docs for longform notes because it was more comfortable to write in, I could write quickly with markdown, and it had proper code-block support. I could also use Bear's tags and nested tags to more easily track the complex dependencies that I found cumbersome or impossible with Google Docs.

tag functionality in bear

Bear was also just as fast as Any.do for capturing new notes from my phone. Even better, syncing those notes between my phone and laptop was noticeably better with Bear than it previously was with Any.do or Simplenote. This lowered Bear's friction and made me use it more. I previously noticed the other tools' syncing was a bit buggy, but Bear made me realize how much I value great syncing.

Bear replaced Simplenote and Google Docs in one fell swoop, and worked great as I grew from software engineer to tech lead. I created pages for different projects and people, and linked them together with tags. I found myself taking better notes at work, and thinking through ideas outside of work better. I still relied on Any.do for task management, but I found myself consolidating my writing into Bear as much as possible.

A new challenge

I began working more closely with data scientists at work, and wanted to learn a bit of machine learning. I knew the best way for me to learn was to build something, and the type of machine learning I was most interested in involved using past data to predict the future.

Around this time, NFL play-by-play data was becoming more accessible. It was the beginning of an analytics revolution in American football, and a really fun time to be learning data science as a football fan. I set out to use the new play-by-play data to predict future football games. This was a new type of research for me:

  • There's an existing history of academic papers where people try to use different kinds of statistics and machine learning to predict sports games. I wanted to read and synthesize this existing work to learn how I might go about doing something similar with new data.
  • I needed to learn the basics behind how different machine learning algorithms work. I didn't need to understand the details of all of the math, but I needed to know enough to figure out which models and algorithms would be appropriate for me to use.
  • I needed to learn how to setup a machine learning pipeline to ingest the data, train a model and test it.
  • Most of the NFL work at the time was being done in R, but I wanted to do my work in Python, which I also needed to learn.

I started the project using Bear, and made heavy use of its nested tags to organize papers and ideas:

using nested tags to try to organize my NFL papers

I felt the limitations of these tags, but resolved to continue using Bear and my whiteboard to finish the project:

diagram of my NFL model from the whiteboard in my office

I managed to create a model that predicted games a little bit better than Vegas, but I was starting to feel the limitations of Bear's nested tags. I didn't know it yet, but I was yearning for bidirectional links.

Towards Roam

Towards the end of 2019 I came across Roam Research. Its focus on networked thought and connecting ideas together made me think it would work well for more complex projects like the NFL model. I resolved to move my NFL notes from Bear to Roam, and hopefully construct some new ideas along the way.

At the time, I didn't think Roam could replace Bear as my "daily driver" because it was slow to open on desktop and lacked mobile support. I didn't have the bandwidth to continue using Bear, and start to port things to Roam, so I put the football project on the backburner and continued using Bear for a bit.

It was later in 2020, a few weeks into the pandemic, that I tried Roam again. I bought a philosophy textbook that I intended to read and take notes on. I used Roam exclusively for this purpose at first. It was impossible to escape Roam's Daily Notes section, and eventually I found myself using Roam and its new primitives more and more:

  • Automatic new "Daily Note" every 24 hours, each with a taggable page name you can reference in the past or future
  • Bidirectional linking — more powerful than the nested tags I was abusing in Bear
  • Block references — I could reference more granular pieces of information, and thereby connect more granular ideas together

These worked well for me, and I quickly found myself using Roam instead of Any.do for basic task management. In the same way that Any.do helped me create more actionable tasks than I could in Simplenote, Roam helped me create more contextualized tasks than I could in Any.do. I could tag or reference related ideas, people or links right under the TODO. Tasks with the proper context are easier to get started on, and I found myself procrastinating less and getting more done using Roam for task management than Any.do.

As I transitioned into a management role at work, I began to replace notes I would take in Bear with Roam. I quickly realized that the same things that made Roam a useful tool to manage tasks made it a good tool to manage projects and people.

I started using Roam every day and importing notes from Bear to Roam as needed. I didn't have a good way to use Roam on my phone, but I didn't mind too much. I used Bear for mobile quick capture, and manually moved notes from Bear to Roam when I was back at the laptop. It was a bit cumbersome, but I was spending all day on my laptop anyways, and I was getting a lot from Roam's bidirectional linking and block references. I found Roam made it easier to connect disparate ideas together and spot hidden dependencies between different projects and people. I wrote a bit about how I used Roam at work for RoamBrain, but be advised the screenshots are fictionalized, so they don't make a ton of sense. The concepts and how I use Roam are still applicable.

Roam's native kanban board works well for smaller projects. It takes the place of Trello in the past. However, if I need to build more complex gantt charts or roadmaps for larger projects, Roam lacks the "issue tracking" primitives of tools like Linear.app. I'm hopeful that these primitives will be built into future tools for thought, ideally a mix of integrating existing tools and building new ones.

The Birth of phonetoroam

In March 2021, I quit my day job. I had spent most of the previous year in my apartment, so I was looking forward to spending as much time as possible outside and away from my laptop. Roam's mobile issue was now much more urgent. I needed a way to get notes directly from my phone to roam. I built phonetoroam (now phonetonote) to solve this problem.

SMS quick capture worked well for me. I could go days at a time without opening Roam from my laptop, knowing my notes would be there in the right place the next time I opened it.

Kinopio, data interop and phonetonote

As I continue to unplug and travel, I find myself gravitating towards my iPad more and laptop less. I enjoy the rich interactions afforded by the Apple Pencil in sketching apps like Illustrator. I've explored more visual tools for thought such as kinopio and are.na.

I find Kinopio to be a joy to use, and a powerful tool to untangle complex thoughts. I now use it weekly, and even outlined this blog post in it:

Using Kinopio and Roam side by side forced me to think more about data interoperability for the first time in a while. I wanted my notes to sync between Kinopio and Roam. As I thought more about how to make this happen and learned more about local-first software, I concluded the most sensible path towards general data interoperability is to build on top of existing open standards. To that end, I rebuilt phonetoroam into phonetonote using RSS feeds. It's now trivial to create new phonetonote clients, or integrate phonetonote into other areas of your workflow.

To logseq and beyond

My quick capture tool is now more interoperable than before, but I have done nothing to solve my own syncing issues. First, I am transitioning from Roam to Logseq. Logseq is mostly at feature parity with Roam, but allows you to store your notes as local markdown files. This is similar to how Obsidian works, but to my knowledge Logseq is the first block-based tool for thought to consume regular markdown files. Roam allows offline graphs, but the data is not stored in readable markdown files.

Local markdown files are powerful because I can treat the local files as my source of truth to build future integrations around. Instead of building increasingly complex n-way sync between different tools for thought, I can build different tools that read and write markdown, one at a time.

I am looking forward to a possible future where phonetonote creates a local markdown file that can be processed by any tool for thought that consumes markdown files in this way.

Aside from an architecture that enables data interoperability, logseq makes it easier to extend its functionality with extensions. It's easier to discover new extensions with its plugin marketplace. Their fully documented typescript API makes it easier to write new plugins. I am already using a heatmap plugin that I was previously planning on writing for myself in Roam. Writing, testing and distributing the phonetonote logseq client was a breeze. I'm excited for phonetonote's distribution in logseq's plugin marketplace, an opportunity that Roam has been unable to provide its plugin developers.

The future of tools for thought is bright. I look forward to continuing iterating on my note taking software as my needs change and the tools improve. I'm excited that different tools are headed in the direction of working better together, and I'm excited to do my part to make that future a reality.