The Synthesist

Starting-the-Kernel-Journey—My-LKMP-Experience

2025-12-08T00:00:00Z

Bound by the shackles of Knowledge and fear,
Linux Kernel had me rolling my tears.
Liberation I see was nowhere near,
My love for the kernel seemed to disappear.
Then came the LKMP, that ignited the spark,
Melting those shackles to free me at last.
Now I am free and over my fears,
Patching the kernel without any tears.
GK

Before I write about my experience, I would like to thank my mentors Shuah Khan, David Hunter and Khalid Aziz for providing me this opportunity to become a part of the LKMP - 2025 Fall Program and this wonderful kernel community.

What is LKMP?

LKMP stands for Linux Kernel Mentorship Program. Its actually a remote mentorship program that is conducted by Linux Foundation along with some of the best Kernel Engineers and Maintainers from the community to train the next generation of Linux Kernel developers.

The core objectives of the program are:

Provide remote learning oppurtunity to the aspiring Linux Kernel developers.
Infuse new talent into the Linux Kernel community.
Make the kernel more secure and sustainable.

There are a couple of variants of LKMP program but the one that is currently running is the Bug Fixing variant (Unpaid). You can find more information about the program here : lkmp

Acceptance Into The Program

Once you have created an account at LFX portal and enrolled in the program, you will be given a set of tasks, that you will have to complete within the stipulated deadline (around 3 weeks). These tasks might include writing kernel modules, analyzing syzbot bugs and sending kernel patches.
Along with that you will be also required to complete LFD103 Course
Once you have submitted all the tasks and completed the course, wait until the deadline :)

Please take the tasks pretty seriously. This time only 74 out 486 applicants were selected i.e around 15%. So make sure to give it your best.

Mentorship Info

Communication

For communicating with mentors and peers, we use discord
Patches and their reviews happen over the email.

Before getting selected, I began using neomutt for working with emails. I didnt like the existing themes in neomutt, so decided to submit a theme based on the ayu-dark color palette. That got merged. Therefore if you like ayu-dark theme, make sure to try it using the steps mentioned here.

Its just amazing that for a project Like linux kernel, email acts as the primary way of communication. Initially i was skeptical about how all of this works, but once you start using it, you see the real power of emails. Everything from sending patches, reviewing patches, applying patches becomes so much easier using email. Emails are just extremely flexible.

Meetings

There is a 1hr meeting scheduled everyweek (office hours), where you can clarify your doubts, get your patches reviewed. In the first few office hours, Shuah will also take some tutorial sessions on tools like csope/ctags, cregit, kselftests, syzbot, backporting etc.
Please make sure to attend those tutorial sessions. They will make your life easier and help you understand different aspects of kernel development including setting up a workflow, debugging, testing, finding bugs, backporting etc.
These office hours also allow you to understand how your peers are tackling problems. I was highly inspired by some of my peers during this process and this helped me fix my own problems as well.
David Hunter also conducted an additional session on Bug hunting in the kernel, which I found really effective. This was a hands on session where we discovered new bugs together. Thanks a lot David for this session.

Note Its just amazing, how much patience our mentors had when we got stuck on issues. Shuah and David both went above and beyond trying to help us fix our problems. They did not solve our issues directly, but they made sure to understand the problem and guide us in the right path. Again I cannot emphasize enough, how much that is helpful for mentees. Thanks a lot for helping us, inspiring us and giving us the confidence to submit our patches.

Community

The linux kernel community is beginner friendly in nature. Since we communicate through emails, there are mailing lists for each subsystem in the kernel. You can find a list of these mailing lists at lore.kernel.org

lore is an extremely useful web archive as you can find every patch in there. You can also see the threads associated with those patches. Along with that lore also provides you ways to search for patches that touch perticular file or are specific to perticular author, which can be extremely helpful.

Learning to interact with the community is a key part of kernel development. In order to improve your communication skills, you can go through the lore threads of the subsystem that you are interested in.

In addition, I also took LFC114 Course offered by linux foundation to help me improve in this area.

My Patches

Although I do have some experience working with the kernel as a part of a research project, I still consider myself as a novice in actual kernel development.

Therefore I decided to start slow and focus on submitting three kinds of patches in the kernel,

Fixing documentation build faliures
Fixing static analysis bugs reported by the compiler and internal kernel tools
Fixing syzbot bugs
git log --author="Gopi Krishna Menon" --since=“2025-08-01” --pretty --format=oneline a5160af78be7fcf3ade6caab0a14e349560c96d7 usb: raw-gadget: cap raw_io transfer length to KMALLOC_MAX_SIZE 89194773f5738a0617240ac92b190fbd553e58bc drm/msm: Add NULL check in vm_op_enqueue() 9efb297c520f392ab04bc45544a03770c98c3798 hwmon: (gpd-fan) Fix compilation error in non-ACPI builds 02227b97a8d3ae01bcf12e5e1b5cb6cca9439875 selftests: tty: add tty_tiocsti_test to .gitignore 77cd9210271556aff955551b3e2ef0ae8a2691bd docs: trusted-encrypted: fix htmldocs build error 96b546c241b11a97ba1247580208c554458e7866 Documentation/rtla: rename common_xxx.rst files to common_xxx.txt 7e8f305a081e22ce81aab7f7b9ce01437cbd38b3 docs/zh_CN: Fix malformed table 989ed3cad2fdb7921bf0f9f0f730e1bb065946c2 docs/zh_TW: Fix malformed table 03faea8466713f04a522c52c386124755be960bc selftests/net: add tcp_port_share to .gitignore d496b6f42eb0455caf5d8cb30cf1f01b7fc2a747 mtd: cfi: use struct_size() helper for cfiq allocation cb0c5a60a6f7dd7f35fa5b46fd04dfb66b37fc1e docs: perf: Fujitsu: Fix htmldocs build warnings and errors 5fdb877b4916a1eb2b2c85018c2311855893405b selftests/futex: Fix typos and grammar in futex_priv_hash 05f297c3e39f62f579458a59ab1b1c8bf3fc1c51 KVM: selftests: fix minor typo in cpumodel_subfuncs 70d476b63a1494337f2b9fec1e9b1cab2e6116d3 Documentation/rv: Fix minor typo in monitor_synthesis page 0e6bb6888791656c3973f26da3288323524573c0 docs: folio_queue: Fix minor typo in folio_queue page

There were a number of other dynamic analysis bugs that I attempted as well.

Some of them I almost solved, but the kernel developers sent patches before me 🙂

Things to remember as a kernel developer

Test all your patches. Shuah mentioned this in almost every meeting multiple times. Test your changes extensively and use tools like kselftest to ensure that nothing breaks. On top of this, mention your testing methodology in the email itself when you send the patch. Untested code can result in regressions which can be a headache for everyone including maintainers, authors and the user themselves.
If you dont have the hardware to test the patch, avoid making that patch. Patches can be marked as RFT (Request for Testing), but still its advised not to work on those kinds of patches.
Avoid top posting in emails and instead use interleaved posting or bottom posting when replying. (Posting Style)
Initially, we can work on different subsystems for understanding the workflow but after sometime, you should choose a subsystem of your interest and try to gravitate towards that. This will help you make bigger contributions to the kernel.
Write the commit messages in Imperative Tone
If your patch is not accepted yet, wait for a few weeks. Maintainers are also humans and therefore sometimes things might take time to get reviewed. Look out for the merge window as well. If you dont get a reply for say 2-3 weeks, gently ping the reviewers asking if they could look at the patch. (Just saying ping is a bad idea).
Read the documentation. Usually every subsystem has a slightly different way of accepting patches (they might require specific tags, specific tests to run etc). In that case check the mailing list for that perticular subsystem and see how others have done that.

How to find Bugs in the kernel?

Looking for Documentation Bugs? Run make html-docs
Looking for Static Analysis Bugs?
- Use Sparse, Smatch, Coccinelle
Looking for Dynamic Analysis Bugs?
- syzbot
- Additional tools can be found here

There is one more way. randconfig (For static analysis and build related bugs)

Here is a small script that will run randconfig n number of times and capture the problematic kernel builds.

In simple terms

First it generates a random config for the architecture
Then it builds the kernel using this config
If the build breaks or config has some issues, it logs down the config and the build output so that a human like me can review them and use them for fixing those bugs.

Note : Sometimes this does result in false positives. So be careful about the errors that you are investigating.

randconfig builds should atleast compile. If they fail to do so, that means there is some undeclared dependency and could be a problem in some configuration for some users.

Infact kernel's CI service also does something similar I believe.

#!/bin/bash
# ================================================
# Sequential randconfig builds for linux-next(x86-64)
# ================================================

BUILD_COUNT=10
ARCH="x86_64"
BASE_DIR=/linux_work
LINUX_NEXT_DIR=$BASE_DIR/linux
DATE=`date +"%d-%m-%y"`
LOG_DIR=$BASE_DIR/randconfig-logs/$DATE
CONFIG_FILE=.config
REMOTE=origin
BRANCH=master
NPROC=$(( $(nproc) / 2 ))

# Create log dir if not available
mkdir -p $LOG_DIR
echo "Starting $BUILD_COUNT sequential randconfig builds for $ARCH..."
echo "Logs will be stored in $LOG_DIR"

# Get the latest commits
cd $LINUX_NEXT_DIR
git fetch $REMOTE 
git reset --hard $REMOTE/$BRANCH
COMMIT_INFO=$(git log -1 --oneline)

# All sequential builds
for i in $(seq 1 $BUILD_COUNT); do
    LOG_FILE=build_log.log
    CONFIG_GEN_LOG_FILE=config_gen_log.log
    CONFIG_GEN_LOG_DIR=$LOG_DIR/config-gen-log

    echo "============================="
    echo "Build $i / $BUILD_COUNT"
    echo "============================="

    # Clean old build artifacts
    make mrproper > /dev/null

    # Remove previous logs.
    rm -rf $LOG_FILE
    rm -rf $CONFIG_GEN_LOG_FILE


    # Add the commit info in config_gen_log
    echo $COMMIT_INFO > $CONFIG_GEN_LOG_FILE
    # Generate random config
    make ARCH=$ARCH randconfig >> $CONFIG_GEN_LOG_FILE 2>&1 


    # For unique config name
    CONFIG_HASH=$(sha1sum .config | cut -c1-8)

    # Do we have warning or error when generating config? Log seperately
    if grep -iq "error:" "$CONFIG_GEN_LOG_FILE" || grep -iq "warning:" "$CONFIG_GEN_LOG_FILE"; then
      mkdir -p $CONFIG_GEN_LOG_DIR
      # Copy over the config into config-gen-log folder as config-hash
      cp $CONFIG_FILE $CONFIG_GEN_LOG_DIR/config-$CONFIG_HASH
    fi

    # Add the commit info in build log
    echo $COMMIT_INFO > $LOG_FILE
    # Build the kernel
    make -j$NPROC >> $LOG_FILE 2>&1

    # Check for errors or warnings
    if grep -iq "error:" "$LOG_FILE" || grep -iq "warning:" "$LOG_FILE"; then
      # We store the config file and build log
      ERROR_CONFIG_FILENAME=error_config
      ERROR_BUILD_LOG_FILENAME=error_build_log.log

      # We store the above files in a seperate dir
      ERROR_LOG_DIR=$LOG_DIR/config-$CONFIG_HASH
      mkdir -p $ERROR_LOG_DIR

      # Store the config and build log in here
      mv $CONFIG_FILE $ERROR_LOG_DIR/$ERROR_CONFIG_FILENAME
      mv $LOG_FILE $ERROR_LOG_DIR/$ERROR_BUILD_LOG_FILENAME
      echo "❌  Build $i failed. See $ERROR_LOG_DIR"
    else
      echo "✅  Build $i completed successfully."
    fi
done

echo "All $BUILD_COUNT builds finished."
echo "Logs are in $LOG_DIR"

The output will look something like this where both the config and the output can be used to reproduce the error.

Here error_config represents the kernel config that generates this issue
error_build_log represents the build log which shows the type of error encountered

Bonus Tip : If you wish to run this for different architectures, you can contact the guys over at GCC Compile Farm Project and request access to their machines for doing testing.

Future

I have found my interest in the USB and MM subsystem and wish to make substantial contributions in these areas in the Linux Kernel. Also I would like to become a maintainer at some point in the linux kernel.

If you are interested to get involved with the kernel community and aspire to be a linux kernel developer, I would highly recommend applying for the Linux Kernel Mentorship Program.

Happy Coding !!

It's not that we don't dare do things because they are difficult; rather, they are difficult because we don't dare – Seneca. (From Richard Stallman's personal site)

Dissecting a Simple Linux Kernel Module

2025-07-30T19:00:00Z

Dissecting a Simple Linux Kernel Module

Hi, In this short article we will explore the internal structure of a simple hello world module in the linux kernel, breaking down its anatomy and understanding how it integrates with the kernel.

Environment

Kernel Version : 6.16.0
Build Toolchain : clang 18, LLVM 18
OS : Ubuntu 22.04 / Nixos (Any distro will work)

Basics

The Linux kernel is monolithic in nature. Monolithic kernels lack the extensibility and modularity, which can make the kernel bloated and difficult to manage. Linux kernel solves this problem with kernel modules.

A kernel module is an object file containing code that can be loaded at runtime and can be used to extend the functionality of the kernel. When a module is no longer needed, it can be automatically unloaded, thereby reducing the memory footprint. Modules give several advantages to the kernel, such as extensibility, modularity, low memory footprint, faster compilation, etc. Most of the device drivers in the kernel are implemented in the form of modules, which contributes significantly to the modularity and maintainability of the kernel.

Internally, the kernel consists of a loader that, when requested, can load and map this object file into its own address space. Once mapped, the module can call kernel symbols just like any other part of the kernel.

Having a modular kernel also allows companies to provide their drivers in the form of proprietary binary blobs. This way, the company can apply its licenses to the source code and is not obligated to release the source code. Whether it's a good thing or a bad thing is a different topic (in terms of philosophy, security, etc.), but I guess companies have their reason for doing this.

Source Code

Let us now examine the traditional hello_world module and understand what happens internally.

// SPDX-License-Identifier: GPL-2.0
#include <linux/module.h>

MODULE_DESCRIPTION("A simple hello world module");
MODULE_AUTHOR("Gopi Krishna Menon");
MODULE_LICENSE("GPL");

static int __init hello_mod_init(void)
{
        pr_info("%s: Hello World\n", KBUILD_MODNAME);
        return 0;
}

static void __exit hello_mod_exit(void)
{
        pr_info("%s: Unloading hello_mod\n", KBUILD_MODNAME);
}

module_init(hello_mod_init);
module_exit(hello_mod_exit);

The code illustrates the fundamental structure of a kernel module. Its key components are :

License Identifier (SPDX Identifier)
HeaderFile (module.h)
Module Metadata
Initialization and Cleanup Functions - Entry and Exit Points

License Identifier

The first line // SPDX-License-Identifier: GPL-2.0 indicates the license associated with the source file. Although linux kernel is primarily licensed under GPL, there are several drivers that have a different free license such as MIT, BSD etc. SPDX or Software Package Data Exchange is a freely available open standard that provides a clean and unambiguous way (one line) to indicate the license associated with the source file. If we didnt have the SPDX standard, the license for each of these source files would look something like this :

/*
 * Copyright (C) 2025 Meow
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License...
 */

which is harder to read and can be ambiguous sometimes.

Header File

#include <linux/module.h>

This header provides the necessary kernel API's and macros to create a kernel module. MODULE_DESCRIPTION, MODULE_AUTHOR and MODULE_LICENSE and several other macros are defined within this header file.

Module Metadata

The macros MODULE_DESCRIPTION, MODULE_AUTHOR and MODULE_LICENSE define metadata about the module. This metadata is then embedded into the resulting .ko file that can be read by tools like modinfo or the kernel module loader.

So lets have a look at what these macros distill down to ultimately.

Looking at the definition of MODULE_DESCRIPTION, MODULE_AUTHOR or MODULE_LICENSE we can see that all of these macros boil down to MODULE_INFO.

/* Generic info of form tag = "info" */
#define MODULE_INFO(tag, info) __MODULE_INFO(tag, tag, info)

Here we can observe from the comment that the module info is represented in the form of tag:value pairs.

#define __MODULE_INFO(tag, name, info)                    \
    static const char __UNIQUE_ID(name)[]                 \
        __used __section(".modinfo") __aligned(1)         \
        = __MODULE_INFO_PREFIX __stringify(tag) "=" info

Here UNIQUE_ID ensures that the variable names never clash. Basically it appends UNIQUE_ID prefix to the variable and a unique number as the suffix to the variable. This is necessary because, if we look at the previous code snippet we can see that we pass tag as the name parameter to the macro. Therefore if invoke the macro multiple times (like multiple authors), then it could result in variable name collision which can be avoided using this.

But the variable name is not important here. Whats important is that the data of this variable is added into .modinfo section and the data itself is tag=info. Now modinfo section is very important as it contains the module information.

In case of our hello world module, if we generate the LLVM IR for this module, we can see that this is generated.

To generate the IR for this kernel module what I did is

make V=1 LLVM=1 M=custom_modules/hello_world

From this I extracted the line containing clang invocation and copied that to a seperate bash script where i gave emit-llvm -S option to clang and specified it to generate hello_world.ll file.

@__UNIQUE_ID_description481 = internal constant [40 x i8] c"description=A simple hello world module\00", section ".modinfo", align 1, !dbg !0
@__UNIQUE_ID_author482 = internal constant [26 x i8] c"author=Gopi Krishna Menon\00", section ".modinfo", align 1, !dbg !7
@__UNIQUE_ID_author483 = internal constant [12 x i8] c"author=Meow\00", section ".modinfo", align 1, !dbg !14
@__UNIQUE_ID_license484 = internal constant [12 x i8] c"license=GPL\00", section ".modinfo", align 1, !dbg !19

As we can observe, the data is stored in the form of tag:value pairs. Also I added additional author to show you how UNIQUE_ID is helping here. Now if we look at the hexdump of .modinfo section via readelf, we can see that the data is stored in the same manner inside the section:

readelf -x .modinfo custom_modules/hello_world/hello_world.k

Hex dump of section '.modinfo':
  0x00000000 64657363 72697074 696f6e3d 41207369 description=A si
  0x00000010 6d706c65 2068656c 6c6f2077 6f726c64 mple hello world
  0x00000020 206d6f64 756c6500 61757468 6f723d47  module.author=G
  0x00000030 6f706920 4b726973 686e6120 4d656e6f opi Krishna Meno
  0x00000040 6e006c69 63656e73 653d4750 4c006e61 n.license=GPL.na
  0x00000050 6d653d68 656c6c6f 5f776f72 6c640064 me=hello_world.d
  0x00000060 6570656e 64733d00 73726376 65727369 epends=.srcversi
  0x00000070 6f6e3d32 46374643 31393532 44453044 on=2F7FC1952DE0D
  0x00000080 44453443 30454638 45370076 65726d61 DE4C0EF8E7.verma
  0x00000090 6769633d 362e3136 2e30636c 616e672b gic=6.16.0clang+
  0x000000a0 20534d50 20707265 656d7074 206d6f64  SMP preempt mod
  0x000000b0 5f756e6c 6f616420 6d6f6476 65727369 _unload modversi
  0x000000c0 6f6e7320 00726574 706f6c69 6e653d59 ons .retpoline=Y
  0x000000d0 00

Running modinfo, we can see the .modinfo data

modinfo custom_modules/hello_world/hello_world.ko
filename:       /linux_work/linux-clang/custom_modules/hello_world/hello_world.ko
description:    A simple hello world module
author:         Gopi Krishna Menon
license:        GPL
name:           hello_world
depends:
srcversion:     2F7FC1952DE0DDE4C0EF8E7
vermagic:       6.16.0clang+ SMP preempt mod_unload modversions
retpoline:      Y

Note : In the above code you can observe that there is vermagic, which is also present in the .modinfo section. Basically if you load a module and vermagic of module does not match whats there in the kernel, it wont load the module. =So modules built for one kernel is not compatible with other kernel.=

static int check_modinfo(struct module *mod, struct load_info *info, int flags)
{
    const char *modmagic = get_modinfo(info, "vermagic");
    int err;

    if (flags & MODULE_INIT_IGNORE_VERMAGIC)
        modmagic = NULL;

    /* This is allowed: modprobe --force will invalidate it. */
    if (!modmagic) {
        err = try_to_force_load(mod, "bad vermagic");
        if (err)
            return err;
    } else if (!same_magic(modmagic, vermagic, info->index.vers)) {
        pr_err("%s: version magic '%s' should be '%s'\n",
               info->name, modmagic, vermagic);
        return -ENOEXEC;
    }

    err = check_modinfo_livepatch(mod, info);
    if (err)
        return err;

    return 0;
}

Module License Enforcement

The MODULE_LICENCE macro is not just for display, it has runtime implications. Basically - If you declare MODULE_LICENCE(GPL), the module is treated as GPL compatible - If you declare MODULE_LICENCE(Proprietary) or leave blank, it is not GPL compatible (meaning you cant access kernel symbols which are marked GPL only using EXPORT_SYMBOL_GPL).

Whatever license we have supplied to this macro can impact what symbols can we access from the kernel. So basically if we have used PROPRIETARY licence, then we cannot call or access any symbols from the kernel which are marked GPL only (using EXPORT_SYMBOL).

Initialization and Cleanup Functions

The functions hello_mod_init and hello_mod_exit are initialization and cleanup routines for the module.

static int __init hello_mod_init(void)
{
    pr_info("%s: Hello World\n", KBUILD_MODNAME);
    return 0;
}

static void __exit hello_mod_exit(void)
{
    pr_info("%s: Unloading hello_mod\n", KBUILD_MODNAME);
}

You can think of these as analogous to setup and teardown functions. - hello_mod_init is called when the module is inserted into the kernel. It can be used for setting up resources required for this perticular module - hello_mod_exit is called when the module is removed from the kernel. It can be used for cleaning up any resources acquired during initialization.

Inside the init and exit function, I am simply printing "Hello World" and "Unloading hello_mod" to the kernel ring buffer. Return value of 0 indicates success as usual. If the initialization fails for some reason, you can also return the error code such as -ENOMEM, -EINVAL which the kernel will handle accordingly.

The __init and __exit are annotations which instruct the compiler to place these functions in special section .init.text and .exit.text. The kernel can take this as a hint and can remove the code in these sections when the initialisation or removal is complete. This can help freeing up memory resources.

Finally the macros module_init and module_exit are used to register these functions. module_init basically specifies the driver initialisation entry point. If the module is builtin (compiled into the kernel), then it will be invoked during do_initcalls(), otherwise it will be invoked by do_init_module during module loading

...
    freeinit->init_text = mod->mem[MOD_INIT_TEXT].base;
    freeinit->init_data = mod->mem[MOD_INIT_DATA].base;
    freeinit->init_rodata = mod->mem[MOD_INIT_RODATA].base;

    do_mod_ctors(mod);
    /* Start the module */
    if (mod->init != NULL)
        ret = do_one_initcall(mod->init); /* Here */
    if (ret < 0) {
        goto fail_free_freeinit;
    }
    if (ret > 0) {
        pr_warn("%s: '%s'->init suspiciously returned %d, it should "
            "follow 0/-E convention\n"
            "%s: loading module anyway...\n",
            __func__, mod->name, ret, __func__);
        dump_stack();
    }

    /* Now it's a first class citizen! */
    mod->state = MODULE_STATE_LIVE;
    blocking_notifier_call_chain(&module_notify_list,
                     MODULE_STATE_LIVE, mod);


...

For exit, if it is not built into the kernel, it will be invoked by delete_module syscall which is invoked by rmmod

...
    /* If it has an init func, it must have an exit func to unload */
    if (mod->init && !mod->exit) {
        forced = try_force_unload(flags);
        if (!forced) {
            /* This module can't be removed */
            ret = -EBUSY;
            goto out;
        }
    }

    ret = try_stop_module(mod, flags, &forced);
    if (ret != 0)
        goto out;

    mutex_unlock(&module_mutex);
    /* Final destruction now no one is using it. */
    if (mod->exit != NULL)
        mod->exit(); /* HERE */
    blocking_notifier_call_chain(&module_notify_list,
                     MODULE_STATE_GOING, mod);
    klp_module_going(mod);
    ftrace_release_mod(mod);
...

So yea, this completes the dissection of a simple kernel module, in future articles, I will talk about other macros such as module_param, module_softdep, module_weakdep etc.

Deep Work (Book Review)

2025-07-02T07:00:00Z

Book Review of Deep Work

Memorable Quotes

Ability to concentrate is a skill that gets valuable things done.
You have a finite amount of willpower that becomes depleted as you use it.
I'll live the focused life, because it's the best kind there is.
Who you are, what you think, feel, and do, what you love—is the sum of what you focus on / Your world is the outcome of what you pay attention to.
Once you're wired for distraction, you crave it.
Men of genius themselves were great only by bringing all their power to bear on the point on which they had decided to show their full measure.
To learn hard things quickly, you must focus intensely without distraction.
Develop the habit of letting small bad things happen. If you don't, you'll never find time for the life-changing big things.
The best moments usually occur when a person's body or mind is stretched to its limits in a voluntary effort to accomplish something difficult and worthwhile.
Wooden wheel is not noble, but its shaping can be.
You don't need a rarified job; you need instead a rarified approach to your work.
Once the talent market is made universally accessible, those at the peak of the market thrive while the rest suffer.
Talent is not a commodity you can buy in bulk and combine to reach the needed levels: There's a premium to being the best.
Let your mind become a lens, thanks to the converging rays of attention; let your soul be all intent on whatever it is that is established in your mind as a dominant, wholly absorbing idea.
To master the art of deep work, you must take back control of your time and attention from the many diversions that attempt to steal them.
Idleness is not just a vacation, an indulgence or a vice; it is as indispensable to the brain as vitamin D is to the body, and deprived of it we suffer a mental affliction as disfiguring as rickets … it is, paradoxically, necessary to getting any work done.

Why I Picked Up This Book

If you have read my previous book reviews of Atomic Habits and Building a Second Brain, you will remember that those books focused on two key areas : The science of Habit formation and the Art of organising knowledge effectively. Together, these books gave me a fresh perspective on how to approach work and helped me break down tasks into chunks and execute tasks more systematically.

But was it a silver bullet to all of my productivity problems?? Sadly, Nope!

Although these two books cleared a lot of problems in my productivity journey, I found that there were still some tasks, that I missed or left incomplete. Upon reflecting on my journal entries of the past few days, It became clear that there were still missing pieces to the puzzle. The following issues popped up :

How long should I execute a task?
What exactly must be executed and when?
The problem of motivation and willpower especially on cognitively demanding tasks

A number of people have talked to me about motivation and willpower and how they can act as the fuel for achieving your goals and completing tasks. But I am very skeptical about impact of these variables on different types of tasks especially cognitively demanding tasks. As a computer science student who constantly grinds and works on solving different kinds of problems, I have dealt with a lot of cognitively demanding tasks and have observed this is not the case. Sure, it works for many of the tasks and does give a boost but relying on these two variables alone is not enough. Motivation and Willpower and inherently nondeterministic in nature. Motivation tends to fluctuate and depends on many internal and external factors, while Willpower is finite and can be easily depleted. Together I think these both make poor foundations for sustained productivity, especially for cognitively demanding tasks.

After going through the blurb and skimming through a few pages of Deep Work, I realized that Newport was trying to address the same kind of problems I was struggling with.

That's what made me pick up the book.

Personal Reactions

Personally, I found Deep Work to be an engaging and worthwhile in nature. Its still not a silver bullet for all my productivity problems but it definitely helped. Infact it was kind of an eye opener for me because after applying some of the ideas presented in this book and restructuring my schedule, I was able to optimize my time, acomplish more and significantly reduce distractions in my life. Like most books, it has its strength's and weaknesses.

Strength's:

The book is well structured, which makes it easy to follow and digest. - It offers practical advice on how to minimize shallow work and increase the propotion of deep work in your daily life - Many of the ideas presented in this book are accompanied with case studies, which serve as useful reference or models for applying the concepts in real life.

Weaknesses:

At times, the book feels repetitive. The same ideas of focus and concentration are repeated again and again in a way that it did feel boring to me. - While there is novelty in the framing, many of the concepts overlap with other popular productivity books. That said, this is somewhat expected since most productivity frameworks draw from similar roots: cognitive psychology, behavioural psychology, neuroscience and behavioural economics.

One aspect that I particularly appreciated is that, the book clearly defines its target audience. Deep Work is not for everyone, and blindly following its advice may not be effective for all. The author acknowledges this which is great.

Another strength is the balanced approach. When I first saw the book, I genuinely thought it was not practical and would make me adopt a monk mode approach to my productivity problems but thankfully that was not the case. Instead this book guides you in recognizing distractions, reducing them gradually and integrate deep work into your schedule in a realistic and sustainable way.

I categorize productivity books into two types : Science based and Tool based. Science based books focus on the underlying research and emperical evidence, while Tool Based books offer direct strategies and Techniques. Deep work clearly falls into the latter category. Infact, most productivity books, that I have encountered are tool based. What sets this book apart though is its emphasis on practical, easy-to-apply advice rather than rigid rules or one size fits all templates. That is what makes it especially useful.

Quick Summary i.e TLDR

Deep Work by Cal Newport is a productivity book, that emphasizes the value of focused, undistracted work in a world full of distractions. The book centers around two core concepts : Deep Work - Focused, cognitively demanding tasks that create real value and Shallow Work - Non demanding, low-value tasks often done while distracted. Newport explains why deep work is crucial in today's economy, arguing that it enables you to learn hard things quickly, deliver better results and gain a professional edge. He also provides practical strategies for scheduling your time, sharpening your focus, minimizing distractions and building habits that support deep, meaningful work.

Things that I find interesting about this book

Deep Work / Shallow Work

Deep Work: Professional activities performed in a state of distraction-free concentration that push your cognitive capabilities to their limit. These efforts create new value, improve your skill, and are hard to replicate.
Shallow Work: Noncognitively demanding, logistical-style tasks, often performed while distracted. These efforts tend not to create much new value in the world and are easy to replicate.

The Deep Work Hypothesis

The ability to perform deep work is becoming increasingly rare at exactly the same time it is becoming increasingly valuable in our economy.

Philosophy of Deep Work Scheduling

There are different philosophies as to how you can implement Deep Work in your life. Choosing the philosophy depends on your occupation, control over work schedule etc.

The Monastic Philosophy of Deep Work Scheduling

Basically dedicate large blocks of time for performing some deep work task and eliminate all shallow work (i.e email, meetings, social media). - Useful for people who have significant control over their work schedule and can isolate themselves from distractions. - Effective for writers, researchers, software developers etc.

The Bimodal Philosophy of Deep Work Scheduling

Suitable for most of the people. - Basically divide your time into blocks of deep work and shallow work so that some obligatory shallow tasks like email are not left unattended. - For each day, you plan in advance the Deep Work blocks and Shallow work blocks in a flexible way.

The Rhythmic Philosophy of Deep Work Scheduling

The goal, is to generate a rhythm (habit) for this work that removes the need for you to invest energy in deciding if and when you're going to go deep.
The main benefit of this technique, as we learned from Atomic Habits as well is that, this reduces the mental energy needed to switch into Deep Work mode.
We can rely on ideas like Temptation Bundling and Habit Stacking from Atomic Habits to make it easy for us to perform this habit.

The Journalistic Philosophy of Deep Work Scheduling

Intended for experts of their field, this approach relies on fitting deep work wherever you can into your schedule. This name is a nod to the fact that journalists, like Walter Isaacson, are trained to shift into a writing mode on a moment's notice, as is required by the deadline-driven nature of their profession.
It is difficult to pull off but if you are confident in the value of what you are trying to produce, and practised in the skill of going deep, it is a robust way to squeeze out large amounts of depth from an otherwise demanding schedule.

Why being Lazy is Not Bad

Idleness is not just a vacation, an indulgence or a vice; it is as indispensable to the brain as vitamin D is to the body, and deprived of it we suffer a mental affliction as disfiguring as rickets … it is, paradoxically, necessary to getting any work done.
At the end of the workday, shut down your consideration of work issues until the next morning—no after-dinner e-mail check, no mental replays of conversations, and no scheming about how you'll handle an upcoming challenge; shut down work thinking completely.
Reasons
- Downtime Aids Insights (Basically our unconscious mind solves the problems)
- Downtime Helps Recharge the Energy Needed to Work Deeply
- The Work That Evening Downtime Replaces Is Usually Not That Important (Basically for incomplete tasks, you can use the to work on them the next day without taking much tension).

Law of the Vital Few to Your Internet Habits

Basically the idea is to apply the 80-20 rule for reducing time on internet or other network tools to reduce shallow work.
Identify your personal goals, Calculate the impact of each network tool on your personal goal and then use only those network tools, that have a positive impact towards that personal goal.

Don't Take Breaks from Distraction. Instead Take Breaks from Focus

Don't take breaks from distractions, instead take breaks from focus i.e Keep focus as the main point and the main thing that you do during the day and allow for small blocks of distractions in it.

The Principle of Least Resistance

If there is no clear feedback on productivity / deep work, we will tend towards behaviour that are easiest in the moment.
The reason we do this is to feel productive. Adding and completing more number of shallow tasks makes us feel productive.
To overcome this, one can utilise the strategies present in the book for Deep Work and add clear feedback.

Parallels to other popular works

This book overlaps with the ideas present in Atomic Habits by James Clear, GTD by David Allen and Building a Second Brain by Tiago Forte

Do I recommend it?

Absolutely 100%. Deep Work is a pretty good book that teaches you how to focus better and reduce/eliminate distractions from your life. It also helps you identify what truly deserves your time and attention, making it easier to prioritise what matters most.

Atomic Habits (Book Review)

2025-06-08T08:00:00Z

Book Review of Atomic Habits

Memorable Quotes

Habits create the foundation for mastery.
Habits are the compound interest of self improvement.
Success is the product of daily habits—not once-in-a-lifetime transformations.
Bad habits repeat themselves again and again not because you don't want to change, but because you have the wrong system for change.
Happiness is the state you enter when you no longer want to change your state.
The trick to doing anything is first cultivating a desire for it.
Being poor is not having too little, it is wanting more.
Good habits make time your ally. Bad habits make time your enemy.
Habits are, simply, reliable solutions to recurring problems in our environment.
Sometimes success is less about making good habits easy and more about making bad habits hard.
The most effective form of motivation is progress.
Never miss twice. If you miss one day, try to get back on track as quickly as possible.
Humans experience peak motivation when working on tasks that are right on the edge of their current abilities
The only way to become excellent is to be endlessly fascinated by doing the same thing over and over. You have to fall in love with boredom.
Professionals stick to the schedule; amateurs let life get in the way.
Until you make the unconscious conscious, it will direct your life and you will call it fate.
The best is the enemy of the good.
Missing once is an accident. Missing twice is the start of a new habit.
Whenever you want to change your behaviour, you can simply ask yourself: How can I make it obvious? How can I make it attractive? How can I make it easy? How can I make it satisfying?
Goals are good for setting a direction, but systems are best for making progress.
You do not rise to the level of your goals. You fall to the level of your systems.
In order to improve for good, you need to solve problems at the systems level. Fix the inputs and the outputs will fix themselves.

Why I Picked Up This Book

What drew me to this book was a simple question : How do I stick to the habits I truly want? I have always felt that I am good at managing good and bad habits but when it comes to the ones that I really aspire to build - I often fell struggled to hold onto them.
Goals give us direction, but its the system's we follow that really help us to progress in life. What I was curious about was - How do we build such systems? What is the science behind making them work.
Bad habits tend to stick around far more stubbornly than good ones. Why is that? We categorize them as good/bad but if we remove that label, What makes certain behaviors so effortless to hold on to? And how does our brain play a role in reinforcing them?”
Habits are automations that are run by the subconscious, requiring little thought or effort. They free up our mental space and quietly shape the way we live and grow. Therefore it was my natural curiosity to understand the science behind them.

Personal Reactions

Honestly, I found this book incredibly fascinating. It helped me pinpoint several issues in my daily routine that were holding back my progress. What stood out to me was the wide range of case studies—from athletes and business coaches to medical professionals—which gave different perspectives and made the concepts easier to relate to and understand.

The idea of identity-based habits really struck a chord with me. When I read about it, something just clicked. There's a huge difference between saying /"I'm learning System's Programming" / and _ "I'm a System's programmer."_ Adopting the latter as part of my identity has given me the confidence to explore challenging and uncertain paths.

Techniques like habit stacking and temptation bundling offer practical formulas I could immediately apply. This is a big relief as instead of drawing in the air, I can rely on a framework that has helped several people. The emphasis on collecting evidence to reinforce identity has also been incredibly valuable. I am using obsidian for tracking my habits.

This has been really helpful as via my journal, I identified why I didn't perform the habit on certain days and then make amendments to my daily lifestyle to become punctual.

Along with that tools like the two-minute rule and the Goldilocks rule have helped me focus better and actually complete tasks.

I even experimented with a habit contract with some friends, and surprisingly, it worked. This not only helped me hold onto my habits but also helped me gain confidence in myself.

The concept of improving just 1% every day is simple yet powerful. I also appreciate the strategies for breaking bad habits—especially the inversion of the laws of behaviour change, which made the process feel manageable and structured.

This book already overlaps a lot with BASB(Building a Second Brain) which was nice and helpful.

Overall, I think the one thing I genuinely loved taking away from this book is "The Idea of Identity Based Habit Building". It way eye opening and is helping me restructure my approach towards everyone and everything in life.

Quick Summary

Atomic Habits is a practical guide to understanding, building and breaking habits. It briefly talks about the science behind habit formation and offers a number of case studies for understanding and applying these concepts in real life. It also emphasises on identity based habits and systems rather than goals setting. Along with that this book also offers the Four Laws of Behavioural Change that are associated with the Habit Loop (Cue, Craving, Response, Reward). This book also offers a number of rules, tools and formula's that you can incorporate into your daily life to manage your habits efficiently. It also offers a good framework for habit tracking. Along with that it also gives a number of strategies to make certain habits exciting which are boring in nature but are required. This book also goes in great length's about how small improvements can have a major impact in your life. Overall this book will help you to reduce procrastination, identify yourself and help become productive in life.

Things that I find interesting about this book

THE SCIENCE OF HOW HABITS WORK (Habit Loop)

Cue triggers your brain to initiate a behavior.
Cravings are the motivational force behind every habit.
The third step is the response. The response is the actual habit you perform, which can take the form of a thought or an action.
Finally, the response delivers a reward. Rewards are the end goal of every habit.
- Rewards satisfy our craving.
- They teach us which actions are worth remembering in future.
cue-> craving -> response -> reward form a neurological feedback loopthat ultimately allows you to create automatic habits. This cycle is known as the habit loop.

THE FOUR LAWS OF BEHAVIOR CHANGE

Creating a Good Habit

Make It Obvious (Cue)
Make It Attractive (Craving)
Make It Easy (Response)
Make It Satisfying (Reward)

Breaking a Bad Habit

Make It Invisible (Cue)
Make It Unattractive (Craving)
Make It Difficult (Response)
Make It Unsatisfying (Reward)

Identity Based Habit Building

Your habits shape your identity, and your identity shapes your habits. Instead of building habits for achieving a goal, we must build habit as a part of our identity.

Example : I am trying to quit smoking vs I am a non smoker

Your behaviors are usually a reflection of your identity. What you do is an indication of the type of person you believe that you are—either consciously or nonconsciously.fn1 Research has shown that once a person believes in a particular aspect of their identity, they are more likely to act in alignment with that belief.
Instead of focusing on goals, we must focus on the systems that lead towards this goal.
The more we perform these habits, the more evidence we are giving to ourselves regarding this identity. This will also help us keep motivated

Two Step Process To Change Your Identity

It is a simple two-step process:
- Decide the type of person you want to be.
- Prove it to yourself with small wins.

The Habit Contract

It is a verbal or written agreement in which you state your commitment to a perticular habit and the punishment that will occur if you don't follow through.

Example : You can create a habit contract that states that you will pay your gym instructor ₹500 for everyday that you dont attend the gym 🥲

We care about the opinions of those around us because it helps if others like us. This is precisely why getting an accountability partner or signing a habit contract can work so well.

Commitment Device

A commitment device is a choice you make in the present that controls your actions in the future. Commitment devices increase the odds that you'll do the right thing in the future by making bad habits difficult in the present.

Example : Paying for a gym membership in advance to force yourself to attend regularly. Sharing your goals with your friend in order to be accountable (Maybe a Habit Contract).

Temptation Bundling

Templtation Bundling is a way of performing those habits, that we procastinate on often. Just like Habit stacking stacking, the idea works by linking an action you want to do with an action you need to .In simple terms, we link a fun activity against a boring one and only allow to do the fun activity, if we complete the boring one.

The underlying idea is to make the habit attractive. Habits are a domain driven feedback loop and not all habits are attractive, therefore strategies like this can be used to make a habit attractive and get more dopamine release.

Desire is the engine that drives behavior. Every action is taken because of the anticipation that precedes it.

We can also combine Habit Stacking with Temptation Bundling and get a formula

After [CURRENT HABIT], I will [HABIT I NEED]. After [HABIT I NEED], I will [HABIT I WANT]

Example : I will only eat from my favourite restaurant, when I implement a feature for my side project I will only watch youtube when I have completed my TODO list for the day

Habit Stacking

Habit Stacking is a powerful technique to build new habits by stacking them together. The idea is based on the Diderot Effect which states that /obtaining a new possession often creates a spiral of consumption that results in acquisition of even more possessions /.

Example : Buying a new phone may lead lead to buying a case, screen protector and ear buds

Basically it leverages the idea that our behaviours often follow a chain reaction - once we start its easier to keep going. You could, for example, start with easier habits and stack difficult habits on top of the easier habit to make it easy to perform that habit.

The habit stacking formula is

"After [CURRENT HABIT], I will [NEW HABIT]."

Example : After boarding the train for work, I will solve 5 puzzles of sudoku and then I will read one chapter of Atomic Habits.

Implementation Intention

It is a plan you make beforehand about when and where to act. That is, how you intend to implement a particular habit. In layman's terms make write down your habits in a clear unambiguous way. That will make it more likely to be followed.

"When situation X arises, I will perform response Y."

Basically cues like time and location must be clearly defined for an habit and not be ambiguous.

Example : After boarding the train for work, I will solve 5 puzzles of sudoku instead of
I will solve 5 puzzles of sudoku in the morning

The Two Minute Rule

The Two Minute Rule states that Once you start a new Habit, it should take less than 2 minutes to do so

It is an excellent way to avoid procastinating a habit and relies on the fact that habit must be established before it can be improved. If the habit is initially easy to perform, then there is a very high chance that we will perform it. We can utilize this to build up our habit and then optimize it.

Standardize before you optimize. You can't improve a habit that doesn't exist.

When we are performing an habit, even if its just two minutes in the beginning, we are enforcing that identity onto ourselves. We are basically creating evidence that yes, this is our identity, this is who I am. Once that sets in, we can slowly increase the time and it would be much easier to enforce that habit.

Example : If you want to become a reader, then create a habit where you read 1 page of the book you are interested in. After sometime, you will have enough evidence to say that you are a reader and therefore you will automatically increase the reading time.

Law of Least Effort

Habits are easier to build when they fit into the flow of your life. The idea behind Law of Least Effort is to modify your environment in such a way that it there is very little to no friction when performing an habit.

Example : Creating an Archipelago of Ideas (BASB) before writing the book review to make it easier to work on the book review Writing a TODO forUsing the Hemingway's bridge to plan for next session of your task, so that its easy to work on that task.

Goldilocks Rule

Goldilocks Rule tells us, how to stay motivated at life and work. It states that humans experience peak motivation when working on tasks that are right on the edge of their current abilities. The greatest threat to success is not failure but boredom. Its based on Yerkes–Dodson law, which describes the optimal level of arousal as the midpoint between boredom and anxiety.

Basically design your habits in such a way that they are a little bit above your ability but not too much.

Small Habits Make Big Improvement

Habits are the compound interest of self improvement. If you introduce small habits regularly and try to improve by atleast 1% then slowly you will start seeing the improvements in yourself.

Basically adding and performing these small habits again and again results in providing more and more evidence towards our identity.

Parallels to other popular works

This book overlaps with the ideas present in Deep Work by New Calport, GTD by David Allen, Building a Second Brain by Tiago Forte, The Power Of Habit by Charles Duhigg.

Do I recommend it?

Yup 100% I would recommend this to anyone who wishes to be productive in life and build a framework for managing, creating and destroying habits.

Building a Second Brain (Book Review)

2025-05-02T11:00:00Z

Book review of Building a Second Brain

Memorable Quotes

You cant wait until everything is perfect.
I think it's important to put your impressions down on the first reading because those are the initial instincts about what you thought was good or what you didn't understand or what you thought was bad.
The biggest obstacle I had to overcome was my own fear and self-doubt—fear that maybe my work really wasn't good enough, maybe I wasn't smart enough; maybe the people telling me I couldn't make it were right.
Use what you have; even if it seems meager, it may be magic in your hands.
Move quickly touch lightly.
It is never a person's toolset that constrains their potential, it's their mindset.
It's crucial to stay organised, but it needs to be done a little at a time in the flow of our normal lives.

Why I Picked Up This Book

The main reason why I picked up this book is to figure out how can I manage all the information that I gather daily and learn to build a second brain. The idea of PKM (Personal Knowledge Management) has been fascinating to me. I always try to observe the nature and capture as much information as possible, but one problem that I always suffered was losing these ideas and information. Whenever I read a book or noticed something interesting, I used to remember that for a good amount of time but overtime, I used to forget the essence of the idea and information which made me unhappy. Even in research, I see a lot of interesting ideas that deeply resonate with me but overtime I forget them and end up back to square one.
Even if I noted down the important stuff, it was not organised in such a way that it could be useful for me. Also I struggle a lot with managing my projects and this book gave me an interesting way to tackle this problem. The idea of PKM came to me through an app called obsidian, which has become my daily note taking and PKM management tool.

Personal Reactions

I find this book really interesting. This book not only teaches us how to build a second brain but also teaches us why building a second brain is useful and help us become more creative in our fields. The moment I started following this book, I tried the ideas present in it and it has significantly helped me in many areas of my life ranging from managing my personal health to my side projects and has helped me identify what I truly love doing. In my research side also this book is helping me to handle the challenging parts of my research despite experiencing burnouts. Even though I am not able to follow everything that i want to follow from this book, I have been able to build up habits that has helped me slowly follow everything and make it a second nature for me. Also most of the productivity books that we read create stringent requirements or give some stupid templates that are difficult to follow and not practical for everyone. (Everyone has their own way of doing stuff and its not necessary that the one way they suggest will help), but this book helped me organise stuff without having any stringent requirements on how I should organise. In-fact the ideas of PARA are so liberating for me as finally I don't have to remember where exactly to store a piece of information. Also this book helped me distinguish the phases of convergence and divergence using CODE, that has significantly helped me to work on something creative. It also helps me link unrelated ideas and finally it has given me the confidence that I can learn anything.

Quick Summary i.e TLDR

This book is about building a second brain to organise your lives. Its also teaches you a system of organisation, why building a second brain is important as well. It also teaches you how to become more productive and tackle challenges related to procrastination and lack of ideas. It also teaches you how to effectively collect and organise information. Along with that It also gives several case studies that can help us understand how to tackle the problems. It also gives a good insight into how we can use the tools effectively to build up our second brain.

Things that I find interesting about this book

12 Favourite Problems

The worthwhile problems are the ones you can really solve or help solve, the ones you can really contribute something to - Richard Feynman

The amount of information that we go through everyday is insane. There is actual information overload happening right now and these 12 problems basically act as a filter on what information we must capture and what information we must not. Here are my 12 favourite problems.

How can I organise myself to become productive and avoid procrastination in my life?
How can I become a great programmer and create achievements in the field of Systems (OS Development, App Development, Compiler Development, Design and Development of Programming Languages)
How can I learn Languages Faster And Help The Community By Building Tooling Around These Languages
How Can I Get Back My Body Back In Shape To Live And Stay Healthy?
How Can I Invest Wisely And Help Myself Build A Rapport For My Future Endeavours?
How Can I Improve My Social Media Presence Via Blogs and YT Videos To Become A Part Of The OSS Community And Help New Comers And Seasoned Programmers
How Can I Be Of Value To Mother Nature And Help In The Development Of Everyone
How Can I Get Back Into Music Again And Have My Own Compositions For My Own Happiness (Preferably Share With The World At Some Point) ?
How Can I Be Clever And Quick Witted And Form Associations And Correlate Things With Relative Ease To Form New Ideas?
How Can I Leverage AI And Other Tech As A Part Of My Daily Life Style?
How Can I Spend More Time With My Loved Ones And Keep Everyone Happy?
How Can I Reduce My Anxiety And Improve My Confidence And Have The Ability To Face Problems In My Life With Relative Ease?

PARA

PARA stands for Projects, Areas, Resources and Archives. It is a method of organising your knowledge. One of the most important thing about PARA is the non static nature of notes. Usually when we write some note, we are stuck in the dilemma of where to place it. We try to place the notes in an optimal location but enforcing that kind of structure makes it difficult to link these ideas together and we usually forget about them. PARA gives you the freedom to organise notes wherever you want and also allows you to keep unrelated ideas together to form new ideas.

The main idea of taking notes is to make it easy to reference later, help us join the dots and not make us remember every single thing. And an organisation method like PARA helps us do it efficiently.

CODE

CODE framework provides a structured way to manage information and create the second brain. It consists of four steps i.e - Capture : Deals with how and what information to capture in the form of notes. - Organise : How to organise this information (PARA). - Distill : Capturing insights, Summarization etc (Discoverability, Progressive Summarization Technique) - Express : How and why to share this distilled information with the outside world. The Express step is where we practice and hone our ability to retrieve what we need, when we need it.

Divergence and Convergence - A creative balancing act

This is one of my favourite parts of the book. It teaches us techniques on how to do something creative by separating the acts of information collection and working on that information. It plugs into the CODE framework and tells us which parts of CODE must be done in convergent mode and which ones in divergent mode.

Intermediate Packets - The Power of Thinking Small

Basically how to create standalone units of information that can be used across different context. This also helps us to link stuff together and become creative.

The Mise-en-Place Way to Sustainable Productivity

This one talks about the importance of habit formation and teaches us how to automate many of the CODE tasks via habits.

Hemingway Bridge - Use Yesterday's Momentum Today

This one serves to reduce the cognitive overload involved when resuming some paused task. There are times when we cannot complete a task in a single sitting. Resume the task next day is difficult and we might have to go through it again to get started. The Hemingway Bridge is a way of making each creative leap from one island to the next less dramatic and risky: you keep some energy and imagination in reserve and use it as a launchpad for the next step in your progress.

The Archipelago of Ideas

This one talks about creating stepping stones from the intermediate packets to help you become creative.
The Archipelago of Ideas technique is a contemporary reinvention of “the age-old practice of outlining;—laying out the points you want to include up front, so that when it comes time to execute all you have to do is string them together.
An Archipelago of Ideas separates the two activities your brain has the most difficulty performing at the same time: choosing ideas (known as selection) and arranging them into a logical flow (known as sequencing).

Parallels to other popular works

GTD by David Allen, Deep Work By New Calport, Atomic Habits. This book does not aim to compete against them but rather act as a extension to their works so that the ideas presented in all of these books can be utilised effectively.

Do I recommend it?

100% I recommend it to anyone who wishes to learn, how to organise the information in their life in such a way that it can be useful when you really want it to. I even gifted this to my cousin as a way to help them organise the information and help generate new ideas.