One of the best parts of working in computer science is that our jobs center on solving problems. While many of us joke that continually struggling to figure things out is frustrating, we do it because there is nothing quite like that feeling of finding a solution. Then, of course, the momentary euphoria ends, and we move onto the next problem.
The hope is that our solution is another data point that propels us towards becoming a more accomplished and effective engineer. But what about all the times we encounter an old problem, one we've already solved, and cannot remember where we found that one, tiny piece of information that allowed us to fix it? Being an engineer can often feel a bit like you're living through Groundhog Day, always in a place where you know you've solved something sort of kind of like this before. My solution to this is a developer journal.
Benefits of developer journals
The idea behind a developer journal is that making relevant notes as you go about your tasks can help the future you. The technology industry requires us to continuously learn new technologies, deepen our understanding, and be able to handle quick, one-off uses of one tool or another—it's all part of this line of work. Having a journal helps you keep track of your learnings. Even if you work with a tool only briefly, being able to reference your journal the next time you use the tool can limit that loss of muscle memory and improve your recall. However, that's not its only benefit.
Einstein's advice to "never memorize something that you can look up" is a concept many engineers take to heart. Choosing not to memorize things may clear up some space in our brain to focus on the bigger-picture problem. However, when we look things up, we're using time and energy and taking ourselves out of the development flow. A developer journal allows us to strike a balance between memorizing everything and looking things up every time we encounter them. If the content you're looking for is written in your own terms, somewhere that's easily accessed, your life as an engineer just became easier.
The ultimate benefit of a developer journal is one of morale. We tend not to see our day-to-day progress; we only realize how much we've grown when we look back over periods of time. Having a physical manifestation of growth is a wonderful thing. Maybe you wrote something down a year ago that you no longer need to reference now. Maybe you've matured from simpler tasks to much more complex ones or mastered a technology you could barely understand before. A developer journal is an excellent history of all that you've done.
Types of developer journals
Developer journals are personal, but they usually encompass a mix of solutions, notes, helpful tricks, and quick links to resources. Because they are made to fit individual preferences, they can take many different forms.
For example, they can be offline (e.g., a physical, written journal) or online. Digital journal content can be formatted using Markup or some other tool, or plaintext if you prefer. Journals can be organized chronologically or by topic. Finally, journals can be public or private.
Use whatever solution makes your journal most accessible and usable for recording content and finding content when you need it. Luckily, there are many incredible open source tools that you can use to facilitate your developer journal, such as various Linux journaling applications, Evernote-style applications, and command line note-taking apps.
What to put in a journal
If you're not sure what to include in your developer journal, think about what types of resources you use somewhat regularly or as references. A journal might include a code snippet or a link to a particular line in a repository. It's common to put a simple link to a particularly useful blog post or tutorial. One of my most helpful entries is a brief writeup of the process I use to flash firmware onto a board.
Here is a quick example from my developer journal. Last year, I noticed that a process I often used would freeze on me. I kept forgetting the command for manually killing it in terminal, so I wrote it down. The following is a screenshot of my journal entry. It's plaintext, available offline, and unformatted. It's simple, and it works for me. My journal's chronology helps me a lot since I tend to remember when I last needed the answer, even if I don't remember the answer.
So, the next time you find yourself ecstatic that you've solved a problem, write down some quick notes. The next time you come across a resource that really helps, copy the link. And almost more importantly, make a note of the next piece of simple syntax you google. Having a self-curated document of the quick-lookup content that applies most often to your development process is invaluable. Looking back at it over time and recognizing how much you've learned is an added bonus.
9 Comments