Books

I read 10 books this year.

• How to Take Smart Notes - The first book I read this year. It helped me form a note-taking habit. It not only teaches how to take notes but also how to consume knowledge. Highly recommended to anyone.
• The Bullet Journal Method - I picked this up to learn a journaling system. It led me to develop a journaling habit this year. I read it once and re-read parts of it throughout the year to clarify and reinforce certain aspects of the process.
• The War of Art - I discovered this via this podcast episode — I paused it midway to get the book. The book introduced me to the idea of resistance (which I discussed here) that every artist or creative individual faces.
• Turning Pro - This is a sequel to “The War of Art.” I kept both of these books on my table for a while. Whenever I felt distracted from work, I made myself pick up and read these books instead of doing something else. That usually helped me return to work energized.
• Self-Led - This book is about Internal Family Systems. After reading it, I’ve been observing my “self” and noticing a phenomenon called “Parts Party” (the idea of how one thing leads to another emotionally). Overall, this has made me more self-aware and conscious of how I make others feel. I’m glad I picked up this book earlier this year.
• Dare to Win - My daughter randomly chose this book in the bookstore and gave it to me. I took it as a sign from the universe and bought the book. I like reading these kinds of books when I feel low.
• Excellent Advice for Living: Wisdom I Wish I’d Known Earlier - Assorted advice on a variety of things. Loved it!
• A Little Book of Life - Similar to the previous book, but this one is by Ruskin Bond (the author of many stories I’m reading these days to my daughter).
• The Almanack of Naval Ravikant - Soulful. Complete. Clear. This book calmed me down a lot. It had such a positive impact on me that I chose to gift a copy to my sister.
• Coding Interview Patterns - I chose to read this at the start of the year to overcome my anxiety about the job market and job security. A friend recommended it to me. It’s well written and did the job of reducing my anxiety.

I also started a few more books that I couldn’t complete:

• Four Thousand Weeks - I didn’t complete it, but it still had a great influence on me. I might re-read it from the start if I get the chance.
• Dopamine Nation - I have been hearing to some podcasts about dopamine that has made me more mindful about how I spend my energy. I guess I ran out of dopamine to complete this book 😅 I will revisit this book only when I feel like I am misusing my dopamine.
• The Idea Factory - This books is about the engineers who worked at Bell Labs (The birthplace of various breakthrough technologies like Transistors, UNIX, C, etc.)
• API Security in Action - Left halfway because O’Reilly free trial ended ended - lol. But also I found what I was looking for. The thing that completed my journey here was reading through the docs of Ory Hydra.
• PostgreSQL 14 Internals - My strategy for getting strong with Postgres is to read this book and look at what happened in the future releases of Postgres. It is kind of an intense book and demands certain level of energy.

Gadgets

I love trying out and using new gadgets. Here are some gadgets I got this year:

• ThinkPad P16s Gen 2 – I received a laptop refresh at work. Previously, I used a Dell XPS 15 and several older ThinkPads, so it was finally time for something new. My personal (and controversial) preference is still the XPS 15 over any ThinkPad. The good thing about ThinkPads is that Ubuntu runs smoothly on them out of the box.
• OnePlus Nord Buds 2r – I got these as a gift. I’ve always preferred wired audio devices—Apple EarPods (wired) have been my primary choice for the past five years. For some reason, I gave these wireless buds a try, and they’ve become my main audio device. I’ve overcome my “wired” obsession because wireless clearly wins in certain situations (for example, wireless is so much better than wired headphones while washing dishes).
• Moto razr 60 – I’ve been using the Moto g82 for the past three years and have wanted to try a foldable phone. I wished for a Samsung Galaxy Z Fold7, but it’s way out of my league price-wise. Hopefully, foldables will become more affordable in the future. I got my hands on the razr 60 in December, so it’s too soon to say much about it.
• Saregama Carvaan – This is my most loved gadget of the year (picture below). It comes loaded with playlists of retro songs. You can often find me carrying this box around the house and playing tunes whenever I feel like it. My favorite playlist is “Top 300.” Overall, I think I listened to more songs on this box than on Spotify this year.

Work

• New title: “Staff Software Engineer” 🎉
• This year marks half a decade with my current employer: Hasura / PromptQL and a full decade working at various startups.
• What I have realized over these years is that, there are going to be ups and downs in every org. It is best to focus on learning and getting better and making the most out of our time.
• The essence of my journey had been “show up, ship things, and help others ship” - I like it this way!

Finance

• 🚗 Fixed my car loan.
• 💲 Fixed personal loans from the past.
• 🏦 Did decent in savings :)
• Doing bad in investments, but it is okay for a guy who had been floating in loans from the past.

Events

I showed up at only one in-person tech event this whole year. It was at BLR Go Meetup (Jan) - I helped with getting my employer to be the venue sponsor for this meetup. One thing I loved about this meetup was that they gave the mic to everyone in the room. They have to introduce themselves to the crowd and tell what they are looking to learn out of that meetup. I shared how I discovered Go programming in BMTC (public bus transport of Bangalore) and made a whole bunch of people to laugh/smile. Reflecting back, I feel like that is one of the proudest things I have done in 2025 - putting smiles on faces :)

I did get a chance to watch the recordings of a few conferences.

• SOSS Days India
• FOSDEM 2025 Go Videos
• Some GopherCon EU 2025 videos
• Currently active: GopherCon US 2025

Habits

Some habits that I formed this year:

• Taking notes while reading books
• Bullet journal
• Drinking coffee in the morning (successfully quit this too — lol :D)
• Drinking tea in the evening (actively in the process of quitting this)
• Switching to warm lighting at night
• Maintaining less than an hour of screen time per day on mobile
• Opening my journal instead of my phone as the first thing in the morning

Note Taking

I’m proud of my note-taking journey. I blogged about my note-taking setup here earlier this year. I’ve tweaked it a bit to fit into my bullet journal, but the core principles remain the same.

All my notes end up in my Obsidian vault. To celebrate my progress, I’m going to share my knowledge graph from Obsidian. This is how it looked around the start of the year:

And this is how it looks now:

Journals

This was the biggest productivity experiment I ran throughout the year. I chose bullet journals as my system for journaling. I remixed and adapted a few things, but overall I’m happy with the outcomes.

One thing I missed in my process was not reflecting enough. I want to improve in that aspect.

I think the bullet journal book clearly advocates using paper notebooks for journaling (analog). I ran a micro-experiment to go all digital with the help of Obsidian. The outcome: paper wins! I still use Obsidian, but mostly for notes and sometimes as a digital scratchpad. Paper notebooks are a clear winner—they can slow down time for you!

Mantras

Some things I needed to consciously repeat to myself — hopefully to ingrain them in my behavior:

• Order matters: Brush, Bath, Pray, Eat.
• Do not talk about work with my wife.
• Overcome Resistance.
• Attention residue is real.
• Acquire “Specific Knowledge” every day.
• Calm down and observe the situation. You’ll find a way forward.
• Watch your mood, rest up, and rejuvenate.
• Meditate multiple times a day. Life has tangled so much that one won’t cut it.
• Drop judgments. See what could be good in any situation.

50% have become second nature to me. I am still working on the rest.

Side Projects

I tried working on two side projects this year. Both of them flopped, and I had to stop working on them.

• gokakashi – Open source. Built with friends from work (mostly to deploy at work). Stack: Go + Postgres + Vite + React. We had to replace it with something like this. This is a story in itself with a good deal of learning (saving it for another time).
• A small app I built for my cousin with Next.js + Postgres + Tailwind + shadcn/ui. We had to throw it away because I struggled to find time to make it useful, and my cousin went back to doing things his old way. But this was a valuable learning experience for me. I probably tried out most of the AI-assisted coding tools in the market while working on this project and formed my opinions about them.

If I have to set a goal for side projects, it would be to build something that stands the test of time.

~ ~ ~ ~

Overall, I feel good about all the progress I’ve made this year. I want to keep up the good work and focus on improving!

To tell what that is, I must quote a few lines from the book:

Most of us have two lives. The life we live, and the unlived life within us. Between the two stands Resistance…..

Are you a writer who doesn’t write, a painter who doesn’t paint, an entrepreneur who never starts a venture? Then you know what Resistance is.

The moment I read those lines, I had this realization: “I have become a blogger who doesn’t blog.”

Today, I want to break that and overcome my resistance to writing blog posts. Because blogging is a soulful act for me. I find it personally rewarding every time I do it, and I always want to do more of it.

So, here I am! Opening up my journal in the middle of the night to write this blog post on paper to overcome my resistance. “Having to turn on my computer every time I want to write a blog post” has become a resistance for me. Not just that, I am sure there are n different things resisting me at a given point in time. But that is okay - I just need to do better at overcoming them!

I don’t know why, but I am finding it fun to write this on paper. The words are flowing faster, and I am saving myself from a little bit of screen time.

I want to do more of this: Resisting my resistance.

Here’s the thing: When you have an idea for a project (that light-bulb moment) or when a friend calls you up and says, “Hey, why don’t we build this side project?” your builder instinct kicks in and replies, “Let’s do it!”

That moment right there is causing a drift in your timeline. I want you to be conscious of that. The thing is, there are only 24 hours in a day, and by signing up to build this new project, you will devote a significant chunk of those hours to it. This might prevent you from doing other activities that are essential for your “work-life balance”.

How do you find time then? Well, you don’t need to find time for projects. Instead, try finding the right projects for your time.

Who is this for?

Before I continue, I would like to state that this piece of advice is contextual and doesn’t apply to everyone. This advice best applies to you if

• You have a full-time job.
• You are living with your family (and looking to spend your precious evenings with them)
• You are having trouble prioritizing “what to work on”, “what to study”, etc.
• You are having trouble scheduling time.
• You are having constant thoughts of building new projects.
• You sometimes regret spending like 10 hours a week on a project that didn’t go anywhere.
• (I guess you get it)

The Framework

The truth is, you are building one of these:

• a project with no users
• a project where you are the user
• a project where you have a user (who is not you)

When you start building a new project, it should fall under one of the above categories. It will eventually lead to one of the following outcomes:

• Best case: Your project is thriving and being used (hopefully by a good number of audience)
• Average case: You hack on your project for a while and eventually forget about it.
• Worst case: You question yourself, “What am I doing with my life?” after weeks/months (hopefully not “years”) of working on the project.

Just like how most startups go nowhere, I am guessing that most of the side projects don’t hit the best-case outcome. They usually end up in worst or average-case outcomes. From my personal experience, I think I have been part of projects that fall under all (if not most) of the categories and outcomes defined above. Based on that, I have come to the following deduction:

First User Framework: Start a project only after you have the first user, who is ready to try it out and provide feedback from day 1.

If a category 1 and 2 (no users and you are the user) project seems attractive to you, then challenge yourself to put yourself out there and turn it into category 3 (you have a first user) and then work on it. Instead of taking four months to build a project that no one uses, you will find yourself making meaningful progress in a week if you are able to qualify the project to be category 3 upfront. (we are looking at exponential time gains here; that should be more attractive to you)

On the other hand, this makes you ruthless about your time and priorities. You might already be working on a short-term goal that is important for you. At times like that, this framework will shine. Either your short-term goal is more important and you pass on the opportunity or this new “category 3” project becomes your short-term goal.

But my passion project?

Usually, passion projects fall under category 1 or 2. So this blog post makes me a villain in the eyes of passion projects. As I mentioned above, this framework is contextual and is written for people who are not finding time and balance in life. If you have the time and freedom to work on a passion project, you should probably do it! There is an immense sense of satisfaction that comes with it.

For example, I did a category 2 (passion) project: a small binary to kick-start my blog writing process. I have been a solo user of it for the past 5 years. I have zero regrets about the time I put into it. So my point is not “don’t work on passion projects”. My point is “Be mindful of your time”.

~ ~ ~ ~

“But my friends are calling me to build the next Google?”

Well, attend the call and ask them, “Where is our first user?”

I responded by saying that I usually have one rule of thumb i.e. to always use of make() whenever I need a channel or map. That way I can be very sure that I can use those immediately.

They added that the surprising thing was it didn’t panic the program rather they ended up with an infinite loop that ran silently. I got more intrigued about the situation. So many questions started popping up in my mind. Why was I not able to catch it in the code review? Why was there no linter rule that could catch this? What is the point of having a nil channel in Go if I am brainwashing myself to always use make()?

I went on to get some answers and here they are!

Nil channel

It is just a channel assigned to nil value.

1

var c chan int

Nothing wrong with it!

Send to a nil channel

When you try to send to a nil channel.

1
2

var c chan int
c <- 1

You get a deadlock.

1
2
3
4
5
6

fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan send (nil chan)]:
main.main()
        /home/vishnu/pers/chanbug/main.go:5 +0x1c
exit status 2

Receive from a nil channel

When you try to receive a value from a nil channel

1
2

var c chan int
<-c

You again get a deadlock.

1
2
3
4
5
6

fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan receive (nil chan)]:
main.main()
        /home/vishnu/pers/chanbug/main.go:5 +0x17
exit status 2

Send and Receive

Now let us try doing both from a nil channel.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

package main

import "fmt"

func main() {
var c chan int

go func() {
defer close(c)
for i := 1; i < 4; i++ {
c <- i
}
}()

for i := range c {
fmt.Println(i)
}
fmt.Println("all done")
}

This ended up with deadlock too.

1
2
3
4
5
6
7
8
9
10
11
12

fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan receive (nil chan)]:
main.main()
        /home/vishnu/pers/chanbug/main.go:15 +0x91

goroutine 18 [chan send (nil chan)]:
main.main.func1()
        /home/vishnu/pers/chanbug/main.go:11 +0x65
created by main.main in goroutine 1
        /home/vishnu/pers/chanbug/main.go:8 +0x35
exit status 2

But my friend mentioned they ran into an infinite loop and not a deadlock. How so?

The for select construct

My immediate suspicion was a for select construct instead of for range construct in the above program.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

func main() {
var c chan int

go func() {
defer close(c)
for i := 1; i < 4; i++ {
c <- i
}
}()

for {
select {
case i := <-c:
fmt.Println(i)
default:
}
}
fmt.Println("all done")
}

Now that leads to an infinite loop without printing anything! Because select seems to not execute the case i := <-c block when c is a nil channel. What can it do after all? It can’t really receive anything from an un-initialized nil channel, right? So it ignores the case block and always runs the default block again and again.

Initialized channel

Now let us initialize the channel by using make(chan int) instead of var c chan int to see how our dear friend select behaves.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

func main() {
c := make(chan int)

go func() {
defer close(c)
for i := 1; i < 4; i++ {
c <- i
}
}()

for {
select {
case i := <-c:
fmt.Println(i)
default:
}
}
fmt.Println("all done")
}

It was again an infinite loop, but this time the output was different.

1
2
3
4
5
6
7
8
9
10
11

$ go run main.go | head -n 10
1
2
3
0
0
0
0
0
0
0

The zeros took over the output. I had to pipe the output to head to stop the program from running infinitely and at the same time collect some sample output.

What are these zeros? Where are they coming from?

Those are arising from the case i := <-c block of the select. When the channel is not nil, our select statement attempts to receive a value. That results in printing 1 2 3, the three values that were sent to the channel. When we close a channel, all we get is the zero value. Hence we are getting zeros after that.

Is there a way to check if a channel is closed? yes, there is.

1
2
3
4
5
6
7
8
9
10

for {
select {
case i, ok := <-c:
if ok {
fmt.Println(i)
}
default:
}
}
fmt.Println("all done")  // this is still unreachable

We avoided printing zeros, but it is still leading to an infinite loop. Because the select is alternating between case and default blocks and continuously executes them.

Let us get rid of default.

1
2
3
4
5
6
7
8
9

for {
select {
case i, ok := <-c:
if ok {
fmt.Println(i)
}
}
}
fmt.Println("all done")  // this is still unreachable

That didn’t prevent the infinite loop, our friend select is going on and on choose the case i, ok := <-c block and performing the if condition that evaluates to false always as the channel is closed after sending 3.

The lesson

How do we avoid the infinite loop? Remember how the select statement ignored the case block when my friend accidentally used the nil channel instead of an initialized channel at the start of this post? That is exactly what we need to disable the case in the select statement.

1
2
3
4
5
6
7
8
9
10
11

for {
select {
case i, ok := <-c:
if !ok {
c = nil
break
}
fmt.Println(i)
}
}
fmt.Println("all done") // this is still unreachable

Now we are out of an infinite loop but are hitting a deadlock after the channel is closed.

1
2
3
4
5
6
7
8
9

1
2
3
fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan receive (nil chan)]:
main.main()
        /home/vishnu/pers/chanbug/main.go:19 +0xa8
exit status 2

Because after we disable the case, the select statement essentially reduces to an empty select clause.

1
2
3
4
5

package main

func main() {
select {}
}

Makes the go routine sleep forever, there is no case statement that it can listen to for receiving a message.

The core lesson however is

nil channels are useful for disabling case blocks of select

I kind of arrived at this lesson in a weird way, but this just for func episode teaches it in a beautiful way. (Thanks Campoy if you are reading this!)

This is particularly useful when you are dealing with multiple channels in different cases of a select and if you want to diable the case blocks one by one when those channels are no longer needed. Going to copy-paste the example from that justforfunc episode to capture the idea.

The problem is to merge values coming from two channels and output them in another channel.

1
2
3
4
5
6
7
8

func main() {
a := asChan(1, 3, 5, 7)
b := asChan(2, 4, 6, 8)
c := merge(a, b)
for v := range c {
fmt.Println(v)
}
}

Now the merge routine could listen on both the channels and disable the case for a channel after it is closed to make sure that we don’t spend any more CPU time on that case.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

func merge(a, b <-chan int) <-chan int {
c := make(chan int)

go func() {
defer close(c)
for a != nil || b != nil {
select {
case v, ok := <-a:
if !ok {
a = nil
log.Printf("a is done")
continue
}
c <- v
case v, ok := <-b:
if !ok {
b = nil
log.Printf("b is done")
continue
}
c <- v
}
}
}()
return c
}

Beautiful, right?

Now back to our problem.

The solution

Let me solve the rest of the problem just for closure.

One way would be to break to an outer label as shown below. That way,

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

func main() {
c := make(chan int)

go func() {
defer close(c)
for i := 1; i < 4; i++ {
c <- i
}
}()

outer:
for {
select {
case i, ok := <-c:
if !ok {
c = nil
break outer
}
fmt.Println(i)
}
}
fmt.Println("all done")
}

And finally, we get

1
2
3
4

1
2
3
all done

NOTE: this would work without the c = nil statement also.

1
2
3
4
5
6
7
8
9
10
11

outer:
for {
select {
case i, ok := <-c:
if !ok {
break outer
}
fmt.Println(i)
}
}
fmt.Println("all done")

If the above is same as the previous solution, what is the point? We noticed that setting a channel to nil is beneficial when we have multiple cases. In here, I could maybe use that as a check for the for.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

func main() {
c := make(chan int)

go func() {
defer close(c)
for i := 1; i < 4; i++ {
c <- i
}
}()

for c != nil {
select {
case i, ok := <-c:
if !ok {
c = nil
break
}
fmt.Println(i)
}
}
fmt.Println("all done")
}

I should probably start brainwasing myself to make sure I set the channel to nil after consuming it completely. That way I can avoid the weird break label syntax and disable select cases to get more throughput.

Anyhow I know of a simpler solution. So my recommended solution for my friend would be to

• initialize the channel with make()
• use a for range construct instead of for select construct.

That would look like:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

func main() {
c := make(chan int)

go func() {
defer close(c)
for i := 1; i < 4; i++ {
c <- i
}
}()

for i := range c {
fmt.Println(i)
}
fmt.Println("all done")
}

A proverb

The example that I gave was a very “trimmed down” version of what my friend was trying to accomplish in a real-world system. He was trying to consume a channel and split the messages into two other channels. The miss was failing to initialize the channels where the split was occurring.

On the other end, we learned from the justforfunc example that, when we try to merge two channels into one, we could start setting the consumed channel(s) to nil.

This is provoking me to make up a Go proverb of my own 😅 Please excuse me if it sounds bad! You have come so far. So you can’t escape from it now - lol :D

~ ~ ~ ~

“Init when you split, Nil when you merge.”

I have been doing this for a little over a month which makes me very underqualified for this post; nevertheless, I feel like I have acquired a lifelong habit! Also, I am unable to keep quiet because of the pure joy I am finding in the process of it.

So let’s start!

Notebook

I keep a notebook and pen for taking notes.

Cute? Check out the backside:

You might have noticed where I got it from. Yep, it is Miniso.

When I decided to start taking notes, I was searching for a particular kind of notebook and stumbled upon this empty one lying around in the house that satisfied the preconditions. So I kind of stole it from my wife. (She bought it in the first place and has been keeping it for future use)

Miniso is so good at making you buy stuff that you don’t need (ahem, ahem). Excuse me 😅 I don’t want to make you feel guilty for your last purchase from there. So I will rephrase it as they are so good in making you buy things that you will need for the future 😀

Pen

We have ADD gel pens floating around everywhere, so it was my natural choice. These are very lightweight and thin (probably the thinnest pens I have ever used).

There are two variations that we have ADD gel Ceramic and ADD gel designer series. I generally carry the ceramic one.

IIRC I first used an ADD gel back in 2003. They used to be costly and with a wet ink which takes time to dry off. But these pens that I have now seem are on a different spectrum. They are more like ballpoint pens.

The Altman technique

Before I go on discussing how my setup works, we will take a short detour of what I call the “Altman technique” because my setup is a fork of the note-taking setup used by Sam Altman.

I learned this from this video. His suggestions for note-taking are:

• You definitely want a spiral notebook.
• You need to be able to tear off pages from the notebook (hence the spiral bind).
• You want the notebook to lie flat when you open it and keep it on a surface. So you need a hardcover.
• You want something that fits in the pocket.

He likes ripping off pages from the notebook, and reading the notes by keeping the ripped-off pages side-by-side. He crumbles the pages and throws them out once he is done.

He seems to finish off one notebook within 2 or 3 weeks. That is a notebook of 100 pages. That is like 100 / (3*7) = 4.7 which is close enough to Niklas Luhmann (The creator of Zettelkasten). Luhmann took 6 notes per day approx [^1]. Tell me the number of notes that you took in the last day/month/year, I will tell you the number of things you learned. To give an idea, Luhmann took 90,000 notes in his lifetime that helped him produce 58 books and hundreds of articles. So if you are running low on the amount of notes that you take per day/month/year, you will certainly need to retrospect your learning process.

One of the big mindset shifts that I had in Altman’s technique was “you have to tear pages off from your notebook” which is against the conventional note-taking technique that I have tried in school days: “Write something in your notebook and preserve those pages forever like it is history”. That is how you will end up with a pile of notebooks that go unnoticed and thrown away as time progresses.

What is the point of writing the page if all I am going to do is throw away the page at the end of the day? Well, you need to convert that note into an artifact that could be retrieved when you need it in the future. That usually means transferring the note to Zettelkasten (slip-box). While Altman doesn’t mention if he uses Zettelkasten, I guess his equivalent might be to use the note in a document/project he might be working on.

How I use them

I keep it open at that moment when I start reading a book, listening to a podcast, or watching a video.

I pause the watching/reading when I want to take notes. I fill up a page and note its reference (book name, page number, etc.) at the bottom of the page. Most of the time I use both the front and back of the paper for a single note. So I mention the reference on one of those sides.

I was a bit skeptical if my notebook could be carried around easily in a pocket because of the weird form factor. But I was wrong. It is so good to carry around. But I stopped carrying them around in my pockets but I carry them in my backpack. Because I have found myself to be needing them usually when I sit for learning and not in situations like shopping.

What if that next big thought/idea strikes me while I am shopping? lol, no worries. because I will just note it down on my mobile. This is where I introduce you to my other notebook: Obsidian.

When I am learning on my computer or mobile, I take my notes in Obsidian. This is the reason why I don’t carry the notebook in my pocket most of the time because I am mostly on my computer where I have Obsidian.

What do I do with the pages in my notebook? I do the same thing as Altman: tearing them off. Once in a while I sit down and feed my notes into Obsidian and then tear off the pages and throw it off. This is what the transfer looks like in the real world:

I try to keep the lag between the syncing process to be small. I don’t like keeping a lot of notes in my notebook. I want to be ripping of as many pages from my notebook at any point in time as possible. Otherwise, I have to pay the taxes of Zeigarnik effect (the notes that I haven’t yet torn off and synced to my digital Zettelkasten will take up space which could be used for learning some other thing).

I also learned that I could use the Zeigarnik effect to my advantage: If I want to delve into the thoughts of a particular project for a certain period of time (say I want to have thoughts about this topic for the next week), I could just leave the notes in my notebook without tearing off and make them haunt me!

The Graph

Let us go back to where we started: the butterfly site post (you can click on it now)

It is a snapshot of the Obsidian graph. If you haven’t heard of Obsidian before, I don’t want to steal the joy of learning what Obsidian is from you. So I will not talk about it in detail here. I encourage you to see for yourself! Besides I might do a post just about it at some point in the future.

But here is what you need to know. It is a note-taking app. You can implement Zettelkasten with it. You get an awesome graph view - a great dopamine hit every time you watch it. Here is what my graph looks like after 35 days of using it:

Looks pretty, huh?

[^1]: How to Take Smart Notes: One Simple Technique to Boost Writing, Learning and Thinking, page 91.