Personal Knowledge Management on Nicole van der Hoeven

June 2022 Patreon Q&A

Fri, 08 Jul 2022 16:00:39 +0100

So you’re using Obsidian Templater, but what do you do when your template changes? What is YNAB? How do you use daily notes in workspaces? How do you process emails? These questions were sourced from the awesome Patreons that support these videos. Thanks to you all!

How to Use Maps in Obsidian - Leaflet and Kanban

Fri, 24 Jun 2022 17:00:54 +0100

I share how to use maps in Obsidian using the Obsidian Leaflet and Kanban plugins, specifically for planning a move to another country. Using a map and marking places on it is a great way to keep track of your exploration of a country when you’re not quite sure where to live yet!

How to create things with your notes

Fri, 17 Jun 2022 17:37:14 +0100

What do you do with all those notes? In this presentation, I talk about how to create things with your notes. I demonstrate my process of going from raw notes to this very presentation and share some of my strategies for creating output with little effort by learning in public and identifying topics to create content about using existing notes.

On May 19th, I did a talk at the Linking Your Thinking Conference about using your notes (or losing them), and about what we can do to make something useful of all our notes. This was my run through!

Notion vs Obsidian - Databases vs Dataview

Wed, 06 Apr 2022 17:00:26 +0200

Notion and Obsidian are similar in many ways, but they have a fundamental difference in philosophy and the way they structure notes. In this video, I talk about structure as well as Notion databases vs. Obsidian’s Dataview plugin, and tell you why I ultimately ended up with Obsidian.

New in Obsidian: Obsidian Callouts (available now)

Wed, 30 Mar 2022 17:36:20 +0200

Transcript:

One thing I’ve learned from writing technical documentation in the last few years is that good writing is skimmable, at least in the digital age. So since I look at my notes in Obsidian the same way as I do a sort of personal documentation, I think that a lot of the same principles apply.

Today I wanna talk about an early access feature that the Obsidian team rolled out two weeks ago, and it’s called Callouts. So before I demonstrate this, I want to say that this is only available right now in the Insider Build version 0.14, but that build always gets pushed to the public, it’s just a little bit ahead of the public release. So think of this as a bit of a sneak preview. (Note: Obsidian callouts is out now!)

What about Obsidian Admonition?

Now, before Obsidian Callouts was released, I was using something called Obsidian Admonition. So if we go here, I can bring up my Obsidian Admonition page, and it looked something like this.

You would do three backticks. That’s kind of the code block syntax. And you would do something like add note. Maybe you’d have a title here, like reminder, and then you’d have your note here. And because I have Live Preview turned on, if I enter out of this, it’s going to look like this. So this is what Obsidian Admonition always looked like.

So in general, the idea here is that to make your writing more skimmable, you have these kind of, well, callout boxes that highlight sections of your text and make sure that they address something that is about the notes that you’re writing, kind of like meta notes, they’re notes about your notes, but because they’re visually distinguished from the rest of the text, it’s a lot easier for you or for your readers to easily figure out whether something is important to read or only in specific situations.

Admonition/callout example

And that happens a lot in technical documentation, so it’s no secret that I have used it a lot in sort of programming kind of notes. So if we go back to my vault here, let’s look at my note on g. g is a package manager for Go, the language.

And here’s a type of callout or admonition that I used. And this is kind of like this page tells you how to use, what g is and how to use it. But this note, this particular callout, is kind of like an aside. It’s like, hey, just in case you get this error, here’s how to troubleshoot it. And it’s really cool that it’s hidden by, it’s collapsed by default. And you can just click on that, and then it says, oh, if you get the error, g not found, hey, maybe restart your shell session after installation.

So that sort of callout really helps when you’re trying to quickly skim a page. So programming is certainly one use for it, and another one is tutorials in general. You know, I have this a lot for my Obsidian stuff in case I need to say that this only works for Mac or this only works for windows or something like that.

And I also use it a lot in my D&D games. As a Dungeon Master, I have different scenarios that I may not even need to go into depending on what my players decide to do. That is the perfect task for callouts or for admonitions.

Enter Obsidian Callouts

So I was using this admonitions format with a code block for, basically, since I learned about it. It is made by a TTRPG plugin developer called Jeremy Valentine, and he’s made a lot of very popular ones, like the Dice Roller and the Initiative Tracker and Leaflet, and it just goes on and on. But I’m digressing.

This plugin was apparently so good that even the Obsidian team realized that it really should be part of Obsidian, because a key part of Obsidian’s functionality is documentation.

So the big release is that they’ve now incorporated Admonitions-like functionality into core Obsidian, not a core plugin, so it’s not something that you even have to install or enable, it just ships by default with Obsidian, which is really awesome.

How to use Obsidian Callouts

So let’s look into how to use it. I’m going to go to my Obsidian Callouts page here. And the syntax is a little bit different from the admonitions one. Instead of the code blocks with the three backticks, this callouts functionality now uses blockquotes.

> [!info] Your title
> The contents of your note here

So you do a single blockquote like an arrow, and then you do brackets, and then an exclamation point. And then there are a bunch of different types, which we’ll get into, but the most common one, I guess, is note. Then you would put your title here, and then you can put the rest of the note here. So this is now doing it as a blockquote. And if I exit out of that, you’ll see that it has a nice icon of a kinda pencil or pen there, and it is visually distinguished from the rest of the note.

Types of Callouts

note

Now, let’s go into the types, ‘cause there are a few of them.

The first one I already showed you, this is a note. I put this within code blocks just to show you the syntax. And then this is what it looks like. Basically, this is the standard format of callouts, you just change whatever’s here. And then you always put the title outside of the brackets, and then the content of the note below it. So this is what a note looks like. That’s probably the most common.

abstract, summary, tldr

And then another one is abstract, summary, or TLDR.

Now, all of these are the same, so like this is a TLDR, so I can actually edit it here as well. So here in this case, I was using TLDR, but if I do abstract, it’s going to look, actually, it looks a little bit different now that I think about it I thought it was going to look the same, but it’s also dependent on the theme that you’re using.

Yeah, so these three are actually different, even though they’re semantically the same. Well, that’s interesting. I just literally found that out right now as well.

info, todo

And there’s info and todo. So this I believe is the todo. And if I go to info, it looks slightly different, just has a little eye here.

This is what I use for descriptions. What we call it in TTRPG is what we call box text, when players enter a new scene and there’s a part that you read out word for word, rather than improvising it. This is what I use for it.

tip, hint, important

Then you have tips, hint, tip, hint, or important. This one is a tip.

Let’s see what important looks like. All right. Yeah, all right. So there’s some highlighting going on there as well, and it’s marked by an asterisk.

success, check, done

There’s success, check, done. I particularly like, I think it was done. It’s kind of like the todo had a checkbox. This one actually has the check.

questions, help, faq

There’s questions, help, or faq.

warning, caution, attention

There’s warning, caution, or attention, which is what I use for errors or gotchas when you’re programming or something things that you might fall into that I want to call out, because I did fall into it.

fail, failure, missing

And there’s also fail, failure, and missing. So this is all bad stuff, essentially.

danger, error

There’s danger, error. It looks like this with a little lightning symbol.

bug

There’s bug, which I use quite a bit when I’m reporting bugs or documenting bugs, anyway. This example, which kind of looks like abstract, actually.

quote, cite

Quote, and cite, which is kind of a blockquote, except a little bit fancier.

Collapsing and expanding callouts

So as you can see, there are a lot of different types of callouts. And aside from all of those, you can also choose whether it’s collapsed or expanded, and that’s kind of the folding behavior that I showed you earlier. So let’s just do that now as well.

I’m going to say bug, and I’ll say bug detected, let’s say. And this time though, where just before the title, right outside of the parenthesis for the type that I’m using, I’m going to type a minus. And I’ll put, this is a bug. And I get out of that. This is what it looks like.

So it is very different from this one where it’s just expanded by default, that’s a default behavior, but if you add the minus there, that means that you’re saying that this must be minimized or collapsed by default. So then you can always click on that, and look, you see what was in the text there. You can also specify that it’s always expanded by default, but it already is always expanded by default, so you don’t really have to set that, unless you’ve changed the settings.

Benefits of Obsidian Callouts

Better documentation

So this is a really cool and easy way of having these different colors. I know a lot of people that have come from Notion are kind of missing some of that in Obsidian. Well, this is an easy way to do that.

Ability to modify callouts

And you can also change how it looks by modifying either the CSS of the theme or by selecting themes that just really use it and display it to its advantages.

This theme here that I’m using is, let me check that, because I’m sure that people will ask. This is one of the gems of the year, one of the themes that won, it’s called Primary. Yeah, it’s really cool, and it’s on the light setting. This is a test vault.

Callouts are native on Obsidian Publish

And one of the coolest things about this new callouts feature is that it now works natively on Obsidian Publish. So I use Obsidian Publish for my public Obsidian vault, that’s notes.nicolevanderhoeven.com. There’ll be a link in the description if you want to see what that looks like. It’s basically my way of learning in public. And I select different notes to publish on there for people to see, for anybody to see.

Now, for a long time, admonitions, because it’s a plugin, wouldn’t show up up there. And then there was a way to do it where you can change the CSS and then kind of do it that way, but now that callouts is in core Obsidian, you don’t even have to do that. It’s just going to work right out of the box. So all of your notes that have the Obsidian callout syntax on them will show up the same way in your Obsidian Publish site, which is really awesome.

Why did the format change from Admonition to callouts?

So you might think, this is really just a format change, right? From admonition to callout, and part of it is that. I asked about why they changed the format, and the answer was that having the blockquote format falls back to blockquotes in unsupported Markdown renderer.

New format works better even if callouts aren’t supported

So for example, if you’re reading this note in an ID and IDE that doesn’t support that syntax, it’s at least still just going to look like a blockquote, which does make more sense than it looking like a code block, because you might not have code there. This is not just for code, this is for any sort of like sticky note that you wanna put on your notes.

Markdown inside blockquotes gets parsed

And also because it just uses blockquotes, this means that all of the Markdown inside it also gets parsed, including links and embeds and even Dataview queries apparently.

And that also means that spellcheck can check it. Because if you put something in a code block, that’s kind of a signal for spellchecks not to have a look at the contents of that code block.

Does this completely replace Obsidian Admonition?

So, what happens with admonition? Because it’s been around for a while, it’s actually still up. And in fact, admonition-style code blocks will continue to work. They’re now supporting, Obsidian is now supporting both the callouts and admonition if you have admonition plugin still enabled, then you’re still going to be able to use both. So it’s not like it’s going away, but you should probably use the callout syntax going forward, just because that’s what everyone’s going to be developing based off of.

Admonition can convert between formats

So there is also another thing that admonition is going to do is it does conversion. So if you have existing code block admonitions, then those can be converted to callouts. Actually, I want to show where you can find that.

So if you go to settings here and look at admonition, there are a bunch of settings here, but let’s look at, yeah, the conversions. You convert MSDoc admonitions to callouts, and you can convert code block admonitions to callouts as well. Now, this will modify your notes, so just be a little bit careful with it. Save a backup or do a push to Git if you save it in a Git repo like I do. But that’s what admonition is going to be doing.

Admonition lets you change callout appearance

And in addition to that, it’s also shifted to being able to let you change the appearance of those callouts.

So it has a bunch of functionality like, do you wanna add drop shadows? And do you want it to be collapsible by default? Because I said that it’s expanded by default, but you could change that behavior and toggle it. And then, you could still just expand it on a case-by-case basis. But if you don’t specify anything, then it’ll just say that it should be collapsed.

There’s also the add copy button, which is actually really interesting because a lot of times that is something that I just want to copy and paste to like my players or something if I wanna paste a description or if it actually is a code block or some sort of troubleshooting thing, so I enable that. And you can set admonition colors.

You can also change the icons that are loaded there. So right now, admonition uses the Font Awesome icons. So I was showing you all of these different types of callouts, right? But those are the default ones. And admonition adds the Font Awesome ones as well. And you can even add your own types of icons. So you can load additional icons. There’s Octicons and RPG-Awesome, which sounds really interesting, actually.

And a cool effect of that is we need to do this in admonition syntax, so it’s code blocks. Let’s say, let’s just go with question. This is a question. A cool thing that you can do with admonition is you can do icon, and then choose an icon that isn’t already in there. So as an example, I happen to know that there is a Font Awesome icon that’s a cloud, so I’m just going to put cloud there and then I’m going to put, here’s the answer. If I go out there, look, now it looks like a little green cloud, so I can change everything about how it looks. This is still in the admonition syntax, though, but it functions the same way as callouts, just extended.

I really like this for being able to give instructions and then say, you know, this is Apple-only and not for Windows. So that’s really cool.

Should you keep using Obsidian Admonition?

So I guess the question is, and this was my question when I learned about these changes, is it still worthwhile to use admonitions because of all these quality-of-life improvements?

I think it is, because, don’t get me wrong, I’m very happy that callouts is part of Obsidian now, that just made sense for an app that is so focused on notes and note-taking and documentation. You really need these different ways to take notes on your notes.

Custom icons and admonition types

But I do think think that admonition is still worthwhile installing and using if you want to delve down into the specifics of this feature. So if you want different icons that make sense to you, but maybe not to other people, this is still the best way to do it.

User interface for inserting callouts OR admonitions

Another cool thing that I didn’t show, let me show that now, is maybe you don’t want to remember the syntax with either with the blockquotes or with the code blocks.

So with admonition turned on and enable, installed and enabled, you can bring up your command pane, which for me is Command + P, and I’m gonna type in admonition, and then you can just either a callout or an admonition and a bunch of other things as well, but I’m just going to insert a callout. And if you didn’t remember what the types were, they’re all here. And this is what they’re going to look like.

Now, as I mentioned, I think these, the ones that I grouped, are actually supposed to look the same without the admonition plugin, it’s just that either the admonition plugin or my theme is making them look a little bit different, but these are the standard ones.

So then you can choose which one you want. You can have the title there. You can choose whether or not it is collapsible. It even shows you a preview. So let’s insert that. And look, I didn’t have to type out any of that and I didn’t have to remember any of that syntax. So that’s just a nice little upgrade that you can only get with admonitions.

Obsidian callouts is available now

Note: Obsidian callouts is available for all users for free now!

Again, Obsidian callouts, at the time of this recording, is only available in Insider Build version 0.14, which means you can only get it right now, if you need to get it right now, you’d have to pay for the Catalyst plan, which is a one-off $25 fee. I’ve paid that just because I wanted to give back to the Obsidian developers for this amazing tool that they just give for free.

But if you’re willing to wait, this feature, like all features, will soon be publicly available, Insiders just get it a little bit earlier. And when that happens, I’ll pin a comment in the comments below for this video so that you know when it’s available.

And if you’d like to learn about other Obsidian plugins, I do have a video on the top 10 Obsidian plugins, so maybe check that out.

Thank you for watching!

How to Process Notes in Obsidian // Readwise Official Obsidian plugin

Wed, 23 Mar 2022 16:00:28 +0100

How do you process notes in Obsidian? I demonstrate how to use the Readwise Official Obsidian plugin to go from raw content to notes in a Zettelkasten-like Obsidian vault. Sign up for Readwise using my link and get double the trial period.

Note: This post contains an affiliate link for Readwise. Clicking on that link will give you a two-month trial of Readwise, double the usual amount, and they give me a small percentage if you sign up for a plan. Check out My Ethics Statement to see my standards for promotions.

Why I Chose Obsidian Over Roam Research (as a Roam investor)

Wed, 09 Mar 2022 10:03:41 +0100

I was a Roam Research power user, a Believer, and investor before I discovered Obsidian. Here’s why I still ended up choosing Obsidian over Roam as my personal knowledge management tool of choice. My goal with this video is to share with you my reasons for making the choice that I did, not to judge you or anyone else who disagrees. In the end, we all have to decide for ourselves what tool fits best in our lives.

How to Actually Remember What You Learn, for Engineers with Long Reading Lists

Mon, 24 Jan 2022 21:47:59 +0100

Who says you need the terminology of the Zettelkasten process? Here’s how I’ve learned how to learn and how to apply new ideas to my daily work.

If you’re reading this, you probably make your living on what you’ve learned that other people haven’t. Unfortunately, if you don’t have a written system to keep track of new ideas, you’ll probably unlearn everything in a few years.

Most people think reading = learning.

Here’s why reading isn’t enough.

Our brains are best at linking concepts, not at remembering them.
Writing doesn’t help us learn; it IS how we learn.
You can’t learn to swim by reading about it.

If reading isn’t enough, then what should you do instead?

Step 1: Consume

The first step is to consume content, but selectively so.

Content could be a book, a video, a podcast, an article, or even a conversation. Take notes on the author’s main points.

Example: Shape Up is a methodology emphasising iterative cycles, “betting” on work to be done, and building fully integrated slices of work.

Step 2: Redefine

Next, go beyond facts and add your thoughts.

Think about the broader picture of what the author might be saying, and supplement it with your opinions. Example: Shape Up is an Agile methodology concerned with the limits we should apply to different stages of work.

Step 3: Contextualize

Think about what the content means to you, specifically– how does it stack with other things you’ve learned? Where does it fit into your interests? Accept that your context, and your notes, will change.

Example: Shape Up’s idea of fully integrated work supports the notion of context-switching (see: Continuous integration, Multithreading) but could be in contention with productivity concepts like deep work (David Allen), batching, and Productivity Momentum.

It’s your brain!

In the end, nobody can tell you the “right” way to learn.

How to use Dataview and Templater to run JavaScript in Obsidian for automating task management

Sun, 16 Jan 2022 16:30:22 +0100

TIL how to run JavaScript in @obsdmd. A friend of mine had an interesting use case: He had a long reading list from his studies, and wanted to use Obsidian to decide what he could read given a certain amount of time.

TL;DR: Here’s the script. And here’s the end result:

Requires: Obsidian. The Dataview and Templater plugins. Also requires a separate markdown page for every chapter or bite-sized section of the book or course, with the metadata time_required in the YAML frontmatter.

Why Dataview? Dataview can parse that frontmatter, grab the value for time_required, and return a list of pages and links. There is a Dataview Query Language, but dataviewjs is more extensible.

Why Templater? I initially wanted to write a script within a dataviewjs block, but:

Dataview results are only rendered in Preview mode (which I don’t spend much time in)
I hate testing JavaScript within Obsidian.

Instead, I created a folder scripts within my vault and selected it as the “user scripts folder” in Templater settings. Then, I created a script, returnStudyOptions.js. Here’s the gist for that.

In a new note, I typed <% tp.user.returnStudyOptions(tp, 60) %>. This line calls the script I created and also passes 60 minutes as the time available.

I selected “Templater: Replace templates in the active file” from the Command Pane, which runs the script and replaces the line with the script’s returned value, which looks something like this:

I also assigned a hotkey to for replacing the template, for ease of use. That’s it! I thought this was a fun way to learn how to use JavaScript in Obsidian. Thanks to @ealameda for the use case!

Building a DM's Brain Attic

Sat, 15 Jan 2022 16:45:22 +0100

Anyone other DMs have this problem? My TRPGs folder, containing paid third-party assets for D&D and other RPGs, is made up of 37,884 items (287 GB).

Here’s how I make sure I actually get value out of this embarrassment of riches: 👇

Mike from @SlyFlourish wrote an article applying Sherlock Holmes’s brain attic for lazy dungeon masters, and he called it the “[DM Brain Attic](https://slyflourish.com/brain_attic.html". The idea is to collect interesting techniques or ideas and file them away for later.

Sounds like a good idea, but for most of us, this attic is theoretical. We read books, we watch videos, and we read blog posts on monsters and settings and plots, and we trust that they’ll all be saved somewhere in our heads.

That’s not how it works. Our minds are good at making connections, not remembering CRs from monster statblocks. So how do we make this DM Brain Attic less theoretical and more practical?

Read and take notes. If you haven’t read everything you’ve bought, you’re buying too much. Read what you’ve got and write down the parts that are actually relevant to you and your game. Here’s what mine looks like for the first Arcadia (@helloMCDM) issue.

Combine like with like. This is the hard part, because it involves creating a central place for monsters, items, spells, etc. This is my attempt to do this for monsters. It creates one page per monster that includes its source. Here’s a monster example.

Here’s an example for items that includes SRD items and Vault of Magic Items (by @KoboldPress). Each one links to a page for the item with full details.

Resurface via search: You may have noticed the metadata in the previous page. The metadata gives me criteria to search monsters by. Here’s how I can query my monster database using the Dataview plugin for Obsidian.

And here’s the result of that query, returning monsters that fit my criteria and, importantly, which of my PDFs they come from.

Resurface via random table generators. Another way that I resurface content is by using random table generators using the Dice Roller plugin for Obsidian by Jeremy Valentine. Here’s my NPC page, compiled from multiple sources.

Each die icon can be clicked to generate a new “roll”. Here’s a gif for how that works, using stuff from Sly Flourish’s Uncovered Secrets, accessible to his Patreons. Each click “rolls” on a table I’ve defined in a separate note.

Is building a DM Brain Attic a lot of work? Yes.

But how likely is it that I’d use my 287 GB of third-party stuff while preparing for my game if I didn’t have this system? Not very.

At least this way, I’m using what I’ve actually bought and putting good content into a very real DM’s Brain Attic that I can actually scrounge around for good ideas in, before or during a game.

If you’d like to know more, check out this video I made about how I use Obsidian to run and play D&D online:

How to Set Goals in Obsidian for 2022

Wed, 12 Jan 2022 16:58:39 +0100

How do you set goals in Obsidian?

New Year’s Resolutions are infamously left undone. So what should you do instead? OKRs.

Setting OKRs (Objective Key Results) instead of resolutions increases your chances of succeeding. Tracking your progress throughout the year also make sure you’re getting things done. In this video, I talk about what OKRs are and how I’ve set them up in Obsidian for the year ahead.

The Tester's Toolbox Is Flawed

Tue, 11 Jan 2022 16:30:49 +0100

Every tester has a toolbox.

In the toolbox rests a variety of tools for every conceivable purpose. Part of our job, as testers, is to choose the right one for the job. Sounds reasonable, right?

That kind of thinking could be dangerous.

“The right tool for every job” fails for multiple jobs.

You end up with multiple tools. One for accessibility testing. Another for API testing. Another for browser testing. Another for load testing. This is the modern tester’s dilemma: we spend more time working with our tools than with the application under test.

In the real world, including a new tool in your testing stack means a new framework, usually a new programming language, and sometimes even new colleagues with experience in those tools. And what about continuous testing? All those tools have to talk to each other at some point.

More tools = more time, effort, and money.

When choosing tools, prioritize multitools.

A multitool can be used for different purposes and prioritizes flexibility.

Here are a few ways to spot a multitool:

#1: It is a polymath. A multitool is good at many things and is limited in use case only by the imagination of those that use it.

#2: It uses what you know. A multitool is built on languages and frameworks you and your team already know, reducing ramp-up time.

#3 It plays well with others. A multitool doesn’t force you to use it to the exclusion of everything else. It integrates well with best-in-class tools.

When you optimize for individual jobs, you’re missing the big picture. You’re ultimately left holding the ends of multiple tools and creating a kraken of a test suite with all these tools cobbled together.

Instead, prioritize multitools.

Obsidian for the Uninitiated

Mon, 10 Jan 2022 23:07:06 +0100

Obsidian for the Uninitiated

You’ve installed Obsidian and created a new vault. Now what?

Unfortunately, it can be more than a little daunting to get started with. It doesn’t help that there are terms like Zettelkasten and Maps of Content and fleeting notes and digital garden that are all just trying to structure what we all learned to do in primary school.

Start by logging what you’re doing.

Having a rigid structure does wonders for curtailing creativity and plain fun. Instead, I recommend starting small.

Here are some small steps to take after installing Obsidian:

Step 1: Enable the Daily Notes plugin

The most game-changing feature of Obsidian is plugins.

Go into Settings > Core Plugins, and enable the Daily notes plugin.

Then, exit out of the dialog boxes and hit CMD P (Mac) or CTRL P (Windows) to bring up the command pane. Search for and select Daily notes: Open today’s daily note. That creates a new note in your vault with today’s date.

From now on, do this every day and log things you do during the day: things to do, appointments to keep, videos you watched.

Step 2: The next time you consume content, take notes.

Now, the next time you read or watch something interesting, type its title into Obsidian with brackets:[[Cool video I watched]]

It’s now a link. CMD+click on that link, or click the glasses icon on the top right to switch to Preview mode, and then click on the link. You should now have a new note. Write about what you thought of the video.

Step 3: Start identifying and fleshing out ideas.

Keep going with these steps and every now and then, start to identify cool ideas you come across. Create new notes from them just like you did in Step 2. Don’t worry about getting it all; just do it when and until you feel like it.

These three simple steps, over time, will be the foundations of your own Personal Knowlege Management system with Obsidian.

5 Ways to Use Obsidian as a Software Engineer

Sun, 09 Jan 2022 19:20:49 +0100

Yesterday, I wrote about why I think taking notes is the surprising foundation of a tester’s career.

But it’s not just testers. Every software engineer is a knowledge worker, and that means we get paid for what we know. Using a Personal Knowledge Management (PKM) system such as Obsidian.md helps us keep up with the constant barrage of new ideas in tech.

Here are 5 things I use Obsidian for.

#1: My very own Stack Overflow

If you code, you’ve used Stack Overflow.

What if you had your own Stack Overflow, one that contained cheat sheets of every language you’ve ever tried to hack something up in, including only commands relevant to your job? This is exactly what I’ve done for Python recently, and it’s helping me solidify my knowledge.

#2: Tools database

There’s a tool for everything.

To keep them straight, I have a page for every load testing tool I try, with tutorials for how to get started, an assessment of its features, and observations I had while attempting to learn it. Here’s what I have for the load testing tool k6.

Bonus: I also use the Dataview plugin to query tools that fit my criteria.

#3: An Agile workspace

If Agile is good enough for my professional work, it’s good enough for my personal work.

I use the Kanban plugin to keep track of projects, create weekly and monthly review/retro templates, and work iteratively using the Incremental Writing plugin.

#4: A public learning log

Learning in public is the fastest way to improve.

When I’m trying to figure something out, I document my attempts. With Obsidian Publish, I can quickly push this log out to my domain and share them with colleagues to get a quick review so that they can easily follow my train of thought and tell me where I went wrong.

#5: A digital garden of software ideas

Build libraries, not feeds.

I use Obsidian to save things I read/watch/listen to but also to save space for ideas I’ve learned to germinate. I publish notes before they’re fully fleshed out, with the goal of growing everything over time.

Today, I have 4,567 notes, all about things that matter to me.

Every engineer should have a PKM system.

Take Notes, Not Tools

Sat, 08 Jan 2022 17:00:44 +0100

When I first got into testing, I thought that testing was about learning different tools and frameworks.

I learned how to use Neoload, then LoadRunner, then JMeter, and then SeleniumSilkPerformerVisualStudioGatlingPuppeteerPlaywrightk6 in short succession. I took courses on JavaScript, on C, on Java. I ticked off tools like a grocery list.

It didn’t take me long to realize that I still wasn’t a good tester.

Taking notes, not tools, is what makes a good tester.

When you think about it, a lot of things a tester does revolves around taking good notes.

Requirements are just notes on what the business wants to achieve. Test scenarios are notes on situations that the team wants to simulate. Test cases are notes on how a user would use an application. Defects are notes on issues.

The quality of a tester’s notes dictates the quality of their work.

Listen to people, not tool tutorials

Take notes on what users do. Talk to the business. Pore through Google Analytics logs. Piece together a story of the kind of people who use your application, and how they use it.

Take notes on problem areas. Talk to customer support about the most common questions they get– they know more about pain points than anyone else in the company. Talk to the ops engineers who were on call during the last production incident. These problems are what you’ll need to test later.

Take notes on what you’ve learned. If you don’t like learning, you’re in the wrong field. Document everything, even things you think you’ll never forget, because one day, you WILL forget.

Taking notes, not tools, is the foundation every testing career is built on.