Often, the culprit is a single character: The Trailing Dot.

In the Domain Name System (DNS), the difference between api.server.com and api.server.com. is not just syntactic sugar—it fundamentally changes how the request is routed, processed, and secured.

Under the Hood: The Client-Side DNS Journey

Before diving into the dot, it is crucial to understand what actually happens inside your computer (the "client") when you type a URL. Your machine doesn't just shout into the internet; it follows a strict internal procedure.

1. The Application Call: When you type ping server or open a URL, your application calls a standard operating system function (like getaddrinfo() on Linux/Unix).

2. The Stub Resolver: The OS has a small built-in library called the "Stub Resolver." It is not a full DNS server; it is a middleman. Its job is to prepare the packet to be sent to a real DNS server.

3. The Local Checklist: Before sending a packet, the Stub Resolver checks:

   • Local Cache: "Have I looked this up in the last 5 minutes?"

   • The Hosts File: It reads /etc/hosts (or C:\Windows\System32\drivers\etc\hosts) to see if you have manually defined the IP.

   • The Search Logic: This is where the dot matters. If the name is "short" (relative), the resolver attempts to expand it using your network settings.

4. The Upstream Query: Only after these local checks pass does the request leave your computer to hit the Recursive Resolver (usually your ISP or 8.8.8.8).

The Core Analogy: The File System

To understand DNS behavior, it is helpful to look at something we use every day: the Operating System file system.

You have two ways to locate a file:

1. Absolute Path: /home/user/docs/report.txt

   • This path is complete. It starts from the root (/) and leads to the exact destination. It works identically regardless of your current directory.

2. Relative Path: report.txt

   • This path relies on context. It only works if you are currently inside /home/user/docs/.

DNS operates on the exact same principle:

• The Trailing Dot (.) is the DNS equivalent of the root slash (/).

• The Search Domain acts as your "Current Working Directory."

The Two Naming Conventions

1. The Absolute Name (FQDN)

Format: google.com. | api.internal.local.

In the DNS hierarchy, the root is represented by a null label, visualized as a dot. When you append this dot, you create a Fully Qualified Domain Name (FQDN).

• The Instruction: You are telling the resolver, "I am providing the full, unalterable path from the root of the internet. Do not add search suffixes. Do not guess."

2. The Relative Name (Hostname)

Format: google.com | postgres-db

This is the standard format for browsers, curl commands, and configuration files. It is a "partially qualified" name.

• The Instruction: You are telling the resolver, "Here is a name. Please use the local network configuration to figure out where this resource lives."

The Mechanics: The "Search List"

Every operating system maintains a resolver configuration (often found in /etc/resolv.conf on Unix systems). This defines the "Search List"—a prioritized list of suffixes to append to relative names.

search prod.svc.cluster.local svc.cluster.local localdomain

How the Lookup Differs

Scenario A: Relative Name (db-host) The resolver iterates through the list until it finds a match:

1. db-host.prod.svc.cluster.local? (No)

2. db-host.svc.cluster.local? (Yes) -> Connection Established.

Scenario B: Absolute Name (db-host.) The resolver bypasses the list entirely:

1. db-host. (Root lookup) -> Fail (because the internal suffix was skipped).

Real-World Use Cases: When to Use Which?

Understanding the theory is good, but knowing where to apply it is better. Here are specific, defined scenarios for each approach.

1. When to Use Relative Names (No Dot)

A. Application Portability (The "Write Once, Run Anywhere" Rule)

• Scenario: You are writing a microservice that connects to a database.

• Usage: Use db-primary (or env var DB_HOST).

• Why: In your development environment, db-primary resolves to db-primary.dev.local. In production, the exact same code resolves to db-primary.prod.corporate.net. If you hardcoded the FQDN (db.prod.corp.net.), your code would crash immediately in the dev environment.

B. Web Browsers, HTTP Clients, and CORS

• Scenario: Configuring a frontend JavaScript app to call a backend API.

• Usage: https://api.example.com

• Why:

  • Cookies: Browsers often treat example.com and example.com. as different domains. If you log in on the relative domain, your auth cookie won't be sent to the absolute domain.

  • CORS: Cross-Origin Resource Sharing relies on exact string matching. If your server expects Origin: https://site.com, but the browser sends Origin: https://site.com., the request will be blocked.

C. Reverse Proxies and Ingress Controllers

• Scenario: Configuring Nginx, Apache, or a Kubernetes Ingress to route traffic.

• Usage: server_name api.example.com;

• Why: When a browser sends a request, the Host header is typically api.example.com (no dot). If your server configuration matches strictly against api.example.com., the handshake may fail or return a 404 because the strings do not match.

2. When to Use Absolute Names (With Dot)

A. DNS Zone Administration (Preventing CNAME Loops)

• Scenario: You are editing a Bind zone file or Terraform config to point www to a load balancer.

• Usage: CNAME lb.example.net.

• Why: This is the most dangerous trap in DNS administration. If you write CNAME lb.example.net (no dot) inside the zone file for mycompany.com, the DNS server will append the zone origin.

  • Result: www.mycompany.com points to -> lb.example.net.mycompany.com.

  • Fix: Adding the dot (lb.example.net.) forces it to treat the target as external.

B. Email Configuration (MX Records)

• Scenario: Setting up mail routing for your domain.

• Usage: MX 10 mail.google.com.

• Why: Similar to CNAMEs, if you omit the trailing dot in your MX record configuration, your mail server might attempt to deliver emails to mail.google.com.yourdomain.com, causing all incoming mail to bounce.

C. Kubernetes Performance Tuning (The "ndots" Penalty)

• Scenario: A high-traffic service inside Kubernetes calling an external API like api.google.com.

• Usage: api.google.com.

• Why: Kubernetes clusters often have a default ndots:5 setting. This means for any domain with fewer than 5 dots (like google.com), the resolver will cycle through all internal search suffixes before trying the public internet.

  • Relative: Tries google.com.default.svc.cluster.local -> Fail -> Tries google.com.svc.cluster.local -> Fail -> ... -> Finally tries google.com.

  • Absolute: api.google.com. -> Goes straight to the internet.

  • Benefit: For high-volume external calls, using the trailing dot can significantly reduce latency and DNS packet load.

D. Enterprise Authentication (Kerberos & LDAP)

• Scenario: Joining a server to an Active Directory domain or generating keytabs.

• Usage: HOST/server.corp.local@REALM

• Why: Security protocols like Kerberos are extremely pedantic. They require the Canonical Principal Name. If the system resolves the hostname to a short name (server) but the ticket is issued for the FQDN (server.corp.local), authentication fails. Using FQDNs ensures the principal names match exactly.

The Verdict

• Developers: Stick to Relative Names for portability, SSL, and Cookie compatibility.

• DevOps/SysAdmins: Use Absolute Names in DNS Zone files, Terraform, and high-performance Kubernetes external calls.

• Everyone: Use the trailing dot as a "sanity check" to bypass local config during debugging.

This article dives deep into Go’s concurrency model and highlights important practices, patterns, and tools that matter when scaling systems under real-world production loads.

1. Understanding the Go Concurrency Model

Go uses a CSP (Communicating Sequential Processes) model, built around:

• Goroutines: lightweight threads managed by the Go runtime

• Channels: typed conduits for goroutines to communicate

• select statement: to multiplex channel operations

Goroutines

go func() {
    fmt.Println("Running concurrently")
}()

• Extremely lightweight (KBs vs OS thread MBs)

• The runtime multiplexes thousands of goroutines onto a small thread pool

Channels

ch := make(chan int)

// Sender
go func() {
    ch <- 42
}()

// Receiver
value := <-ch
fmt.Println(value)

2. Buffered vs Unbuffered Channels

• Unbuffered: send blocks until receiver is ready

• Buffered: send proceeds immediately if space is available

buffered := make(chan int, 10)
buffered <- 1  // doesn’t block

Use buffered channels to decouple sender/receiver under load.

3. Select Statement

The select block lets you wait on multiple channel operations:

select {
case msg := <-ch1:
    fmt.Println("Received:", msg)
case ch2 <- data:
    fmt.Println("Sent:", data)
default:
    fmt.Println("Nothing ready")
}

Great for implementing timeouts, fallbacks, or managing multiple consumers.

4. Context for Cancellation and Timeouts

In high-throughput systems, timeouts and cancellation propagation are critical.

ctx, cancel := context.WithTimeout(context.Background(), time.Second*2)
defer cancel()

req, err := http.NewRequestWithContext(ctx, "GET", url, nil)

Use context.Context across services, handlers, and goroutines to:

• Cancel requests

• Pass deadlines

• Carry request-scoped values

5. Worker Pools

When handling large volumes of requests or jobs:

tasks := make(chan Task)
for i := 0; i < numWorkers; i++ {
    go func() {
        for task := range tasks {
            process(task)
        }
    }()
}

• Prevents unbounded goroutine creation

• Controls concurrency level

• Enables backpressure when combined with buffered channels

6. Rate Limiting and Throttling

Go’s time.Ticker and time.After let you build leaky-bucket or token-bucket patterns.

For more advanced use:

• golang.org/x/time/rate

• Third-party packages like Uber’s ratelimit

7. Sync Primitives (from sync package)

Though channels are preferred, you can still use:

• sync.Mutex / sync.RWMutex

• sync.Once for single-run init

• sync.WaitGroup for goroutine lifecycle control

var wg sync.WaitGroup
wg.Add(1)
go func() {
    defer wg.Done()
    work()
}()
wg.Wait()

8. Avoiding Common Pitfalls

• Don’t leak goroutines: always close channels and manage exits with select + done or context

• Don’t share memory by default: prefer communication via channels

• Measure: use pprof, runtime.NumGoroutine(), and custom metrics

• Never block the main goroutine: always use WaitGroup or proper shutdown logic

9. Observability in Concurrency

For senior developers in production-grade systems:

• Use net/http/pprof to detect goroutine leaks, mutex contention

• Export Prometheus metrics for:

  • Active goroutines

  • Queue size

  • Request latency percentiles

10. When to Use What

Final Words

Concurrency is Go’s superpower, but mastering it requires discipline. Senior developers must balance simplicity with control — by using goroutines responsibly, applying context across boundaries, managing lifecycle, and observing everything in production.

By sticking to Go idioms and layering your system with backpressure and observability, you can safely scale to thousands of concurrent operations with ease.

Happy scaling!

Why Should You Even Care About Vim/Neovim? 🤔

Let’s be honest. Learning a new tool feels like extra work, especially when your IDE already does everything. But hear me out—what if you could code, navigate, and edit like a machine without ever lifting your hands from the keyboard? No more dragging your mouse around, no more clunky UI menus—just pure, uninterrupted flow.

That’s where Vim and Neovim come in. These aren’t just text editors; they’re efficiency boosters that let you do more with less effort.

🥊 Vim vs. Neovim vs. Other Editors

Long story short:

• Vim is powerful but traditional—great for purists.

• Neovim is Vim’s smarter, younger sibling, built for the modern age.

• VS Code & IntelliJ are great, but bloated and mouse-dependent.

If you’re tired of your mouse slowing you down, this cheatsheet will help you unlock Vim/Neovim superpowers. 🦸‍♂️

🏁 Basic Navigation (a.k.a. "Moving Around Like a Pro")

🚨 Pro Tip: Vim doesn’t use arrow keys (well, you can use them, but real pros don’t). Instead, use HJKL to move.

🎯 Challenge:
Try navigating through a file without using arrow keys. Your fingers will thank you later.

📝 Editing & Inserting (a.k.a. "Actually Writing Stuff")

Vim has modes, and you start in Normal Mode. To type something, you need to enter Insert Mode first.

🚀 Speed Tip:
Instead of pressing Esc every time, map jk or jj to escape mode in your vimrc or init.lua.

🔍 Searching & Replacing

Finding stuff in a file is easy with these commands:

🔥 Pro Trick:
Use * to search for the word under your cursor automatically.

📌 Copy, Paste, and Delete

📌 Tip: Use "0p to paste from the last yank, so deletions don’t overwrite your clipboard.

📂 Working with Files

🖥 Splits & Windows (Multitasking Like a Pro)

🔥 Tabs (Because You Love Having 100 Open at Once)

🚀 Git Integration (via Fugitive Plugin)

🎯 Final Thoughts

Congrats! 🎉 You now have enough Vim/Neovim knowledge to be dangerous.

But don’t stop here—Vim mastery is a journey. The more you practice, the faster and more efficient you’ll become.

💡 Your next step? Try using Vim/Neovim exclusively for one full day. It’ll feel weird at first, but by the end, you’ll be 10x more productive. 🚀

Happy coding! 🎉

Neovim is a modern, extensible, and highly customizable text editor that has gained massive popularity among developers, especially those who value performance, minimalism, and workflow efficiency. While it has its roots in Vim, Neovim brings modern improvements that make it a strong competitor to traditional IDEs like VS Code, WebStorm, and IntelliJ IDEA.

This blog will explore:

• What makes Neovim great

• Key advantages over other editors

• How it compares to VS Code, WebStorm, and IntelliJ

• Who should use Neovim and why

• Installation and setup instructions

• Detailed explanation of configuration files and plugins

✅ What is Neovim?

Neovim is an advanced text editor that evolved from Vim with the goal of improving extensibility, performance, and maintainability. Unlike traditional IDEs, Neovim is minimal by default but can be turned into a full-fledged development environment with the right configurations and plugins.

Neovim is fast, lightweight, and fully customizable, making it a preferred choice for developers who want full control over their development environment.

🔥 Why Neovim is Great

1️⃣ Performance & Speed

Neovim is built for speed. Unlike bloated IDEs that consume large amounts of RAM and CPU, Neovim is optimized for performance, ensuring:

• Instant startup time 🚀

• Minimal system resource usage ⚡

• No lag, even with large files 📄

2️⃣ Extensibility & Plugin Ecosystem

Neovim is designed with Lua-based configuration (instead of Vimscript), making it easier to customize and extend. Developers can:

• Install powerful plugins using lazy.nvim

• Integrate LSP for autocompletion & code analysis

• Add a file explorer, fuzzy finder, Git integration, debugging tools, and more!

3️⃣ Terminal-Based & Distraction-Free

Since Neovim runs inside a terminal, it allows developers to:

• Work efficiently without switching between apps

• Avoid unnecessary UI clutter found in traditional IDEs

• Use powerful keyboard shortcuts for faster navigation 🔥

4️⃣ LSP Support (Like VS Code)

Neovim now supports Language Server Protocol (LSP), giving you:

• Intelligent autocompletion

• Real-time syntax checking

• Refactoring & go-to-definition support

This makes Neovim as powerful as VS Code for TypeScript, JavaScript, Python, Rust, and more.

5️⃣ Full Git Integration

With plugins like fugitive.nvim and gitsigns.nvim, Neovim provides:

• In-editor Git commands

• Inline Git diff markers

• Easy commit, push, pull, and branch management

6️⃣ Runs Everywhere

Neovim works on Linux, macOS, and Windows. It can be used in:

• The terminal (for efficiency)

• A GUI wrapper like Neovide or AstroNvim for a modern experience

✅ Installation and Setup

MacOS

brew install neovim

Ubuntu/Debian

sudo apt install neovim

Windows

Download from 👉 Neovim Releases

Setup Plugin Manager (lazy.nvim)

git clone --filter=blob:none https://github.com/folke/lazy.nvim.git --branch=stable ~/.local/share/nvim/lazy/lazy.nvim

Then, create the Neovim configuration file:

mkdir -p ~/.config/nvim/lua
nvim ~/.config/nvim/init.lua

And add the following:

-- Bootstrap lazy.nvim if not installed
local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
if not vim.loop.fs_stat(lazypath) then
  vim.fn.system({
    "git", "clone", "--filter=blob:none",
    "https://github.com/folke/lazy.nvim.git", "--branch=stable", lazypath
  })
end
vim.opt.rtp:prepend(lazypath)

-- Enable system clipboard support
vim.opt.clipboard = "unnamedplus" -- Uses system clipboard

-- Load Lazy.nvim
require("lazy").setup({
  "nvim-treesitter/nvim-treesitter", -- Syntax highlighting
  "neovim/nvim-lspconfig", -- Language Server Protocol (LSP)
  "hrsh7th/nvim-cmp", -- Autocompletion
  "hrsh7th/cmp-nvim-lsp",
  "hrsh7th/cmp-buffer",
  "hrsh7th/cmp-path",
  "hrsh7th/cmp-cmdline",
  "williamboman/mason.nvim", -- LSP Installer
  "williamboman/mason-lspconfig.nvim",
  "nvim-lua/plenary.nvim",
  "nvim-telescope/telescope.nvim", -- Fuzzy finder
  "nvim-tree/nvim-tree.lua", -- File explorer
  "windwp/nvim-ts-autotag", -- Auto-close JSX/TSX tags
  "windwp/nvim-autopairs", -- Auto-close brackets
  "hoob3rt/lualine.nvim", -- Statusline
  "tpope/vim-fugitive", -- Git integration
  "lewis6991/gitsigns.nvim", -- Git signs in editor
  "akinsho/toggleterm.nvim", -- Terminal inside Neovim
  "tpope/vim-commentary", -- Quick commenting
  "tpope/vim-surround", -- Surround text editing
  "norcalli/nvim-colorizer.lua" -- CSS color preview
})

Explanation of Configuration

• Lazy.nvim – Plugin manager for Neovim

• Treesitter – Enhances syntax highlighting

• LSP Config – Enables language server support for TypeScript, JavaScript, HTML, CSS, etc.

• Telescope – Adds fuzzy searching

• nvim-tree – File explorer

• lualine – Statusline for Neovim

• Git Plugins:

  • vim-fugitive – Git commands inside Neovim

  • gitsigns.nvim – Shows inline Git changes

  • octo.nvim – GitHub PR management

  • github-nvim-theme – Neovim theme matching GitHub

  • blame.nvim – Shows GitHub annotations on files

Install GitHub Plugins using Lazy.nvim:

require("lazy").setup({
  "tpope/vim-fugitive",
  "lewis6991/gitsigns.nvim",
  "pwntester/octo.nvim",
  "projekt0n/github-nvim-theme",
  "APZelos/blame.nvim"
})

Final Looks post installation

🚀 Final Verdict: Why Choose Neovim?

Neovim is an amazing alternative to traditional IDEs. It’s ultra-fast, fully customizable, and perfect for developers who value performance and flexibility. With the right plugins, it can rival even the best GUI-based IDEs while remaining lightweight and efficient.

If you're willing to invest some time in customization, Neovim can boost your productivity like no other editor.

🚀 Now, go ahead and give Neovim a try! Let me know if you need help setting it up. 🔥😊

The file is written for Mac OS, some updates might be needed to support Linux OS

1. Installing the Basics

Install Zsh

Zsh is the default shell on macOS, but if it’s not installed, you can add it:

brew install zsh

Install Oh My Zsh

Oh My Zsh is a framework that makes managing Zsh configurations, themes, and plugins easy:

sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

Install Powerlevel10k Theme

Powerlevel10k is a fast and highly customizable Zsh theme:

git clone --depth=1 https://github.com/romkatv/powerlevel10k.git $ZSH_CUSTOM/themes/powerlevel10k

Set the theme in your .zshrc file:

ZSH_THEME="powerlevel10k/powerlevel10k"

After setting up, run:

p10k configure

This will help you customize the prompt with useful features like Git status, Python environments, and more.

2. Powerlevel10k Instant Prompt

The instant prompt ensures your terminal loads quickly by displaying the prompt even before .zshrc finishes loading. Here’s the relevant configuration:

if [[ -r "${XDG_CACHE_HOME:-$HOME/.cache}/p10k-instant-prompt-${(%):-%n}.zsh" ]]; then
    source "${XDG_CACHE_HOME:-$HOME/.cache}/p10k-instant-prompt-${(%):-%n}.zsh"
fi
# typeset -g POWERLEVEL9K_INSTANT_PROMPT=quiet

• The quiet option suppresses warnings about instant prompt issues.

Why Use It?

• Speed: Terminal loads faster by delaying the execution of heavy tasks.

• Customizability: You can still customize the full prompt via p10k configure.

3. Plugins for Productivity

Oh My Zsh supports plugins that extend the functionality of your terminal. Here are the plugins we’ve defined and how to use them:

Plugin Configuration in .zshrc:

plugins=(
  git
  zsh-autosuggestions
  zsh-syntax-highlighting
  history
  vscode
  kubectl
)

What Each Plugin Does:

1. git: Adds helpful Git aliases and shortcuts:

   • gst for git status

   • gco for git checkout

2. zsh-autosuggestions: Suggests commands based on your history as you type.

   • Use the → key to accept suggestions.

3. zsh-syntax-highlighting: Highlights commands and flags to improve readability and catch errors.

4. history: Enhances your command history management.

   • history shows past commands.

5. vscode: Provides shortcuts for opening files and projects in Visual Studio Code.

   • Example: code . opens the current directory in VS Code.

6. kubectl: Autocompletes and adds shortcuts for Kubernetes CLI commands.

   • Example: k get pods instead of kubectl get pods.

4. Environment Variables

Environment variables are crucial for customizing your development environment. Here’s how they’re configured:

Java Configuration:

export JAVA_HOME=$(/usr/libexec/java_home -v 17)

• What It Does: Points tools like Maven or Gradle to Java version 17.

• Usage: Run echo $JAVA_HOME to verify the Java path.

NVM (Node Version Manager):

if [ -d "$HOME/.nvm" ]; then
    export NVM_DIR="$HOME/.nvm"
    [ -s "$NVM_DIR/nvm.sh" ] && source "$NVM_DIR/nvm.sh"
fi

• What It Does: Enables NVM to manage multiple Node.js versions.

• Usage: Use nvm install <version> to install a specific version of Node.js.

5. Aliases for Efficiency

Aliases are shortcuts for commonly used commands. Here’s how they’re loaded and used:

Loading Aliases:

if [ -d "$HOME/.alias" ] && [ "$(ls -A $HOME/.alias)" ]; then
    for file in $HOME/.alias/*.sh; do
        [ -f "$file" ] && . "$file"
    done
fi

Examples of Aliases:

alias ll="ls -la"
alias gs="git status"
alias gp="git pull"
alias vim="nvim"

• Usage:

  • ll: Lists all files with details.

  • gs: Runs git status.

  • vim: Opens Neovim instead of Vim.

6. Additional Integrations

iTerm2 Integration:

if [ -e "$HOME/.iterm2_shell_integration.zsh" ]; then
    source "$HOME/.iterm2_shell_integration.zsh"
fi

• What It Does: Enhances iTerm2 with features like split panes and session restoration.

Backups and Reloading:

alias backup-zshrc="cp ~/.zshrc ~/.zshrc.backup && echo 'Backup created at ~/.zshrc.backup'"
alias update-zsh="source ~/.zshrc && echo 'Reloaded .zshrc settings'"

• Usage:

  • backup-zshrc: Creates a backup of your .zshrc file.

  • update-zsh: Reloads .zshrc after making changes.

7. Customizing Powerlevel10k

You can customize Powerlevel10k using the following command:

p10k configure

This wizard allows you to set:

• Prompt layout (e.g., minimal, classic).

• Colors, icons, and separators.

• Display options (e.g., Git branch, time, battery level).

If you want to tweak configurations manually, edit ~/.p10k.zsh.

8. Final Touches

Clean Up Unused .env and .alias Files

Ensure there are no unnecessary files in ~/.env and ~/.alias. Only include variables and aliases you actively use.

Restart Zsh

After making changes, reload your shell:

source ~/.zshrc

By following these steps, you’ll have a Zsh terminal that’s not only beautiful but also optimized for productivity.

Complete .zshrc file is added for reference

# Enable Powerlevel10k instant prompt. Should stay close to the top of ~/.zshrc.
if [[ -r "${XDG_CACHE_HOME:-$HOME/.cache}/p10k-instant-prompt-${(%):-%n}.zsh" ]]; then
    source "${XDG_CACHE_HOME:-$HOME/.cache}/p10k-instant-prompt-${(%):-%n}.zsh"
fi

# Suppress Powerlevel10k instant prompt warnings
# typeset -g POWERLEVEL9K_INSTANT_PROMPT=quiet

# Path to your oh-my-zsh installation
export ZSH="$HOME/.oh-my-zsh"

# Theme
ZSH_THEME="powerlevel10k/powerlevel10k"

# Enable command auto-correction
ENABLE_CORRECTION="true"

# Display red dots whilst waiting for completion
COMPLETION_WAITING_DOTS="true"

# Plugins
plugins=(
  git
  zsh-autosuggestions
  zsh-syntax-highlighting
  history
  vscode
  kubectl
)

# Load Oh My Zsh
source $ZSH/oh-my-zsh.sh

# Custom Settings

# Java Home
export JAVA_HOME=$(/usr/libexec/java_home -v 17)

# Vim Keybindings
bindkey -v

# Load Environment Variables from `.env` Directory
if [ -d "$HOME/.env" ] && [ "$(ls -A $HOME/.env)" ]; then
    for file in $HOME/.env/*.env; do
        [ -f "$file" ] && . "$file"
    done
fi

# Load Aliases from `.alias` Directory
if [ -d "$HOME/.alias" ] && [ "$(ls -A $HOME/.alias)" ]; then
    for file in $HOME/.alias/*.sh; do
        [ -f "$file" ] && . "$file"
    done
fi

# Additional Path Updates (already moved to system-paths.env)
export PATH="$PATH"

# Enable NVM (Node Version Manager)
if [ -d "$HOME/.nvm" ]; then
    export NVM_DIR="$HOME/.nvm"
    if [ -s "$NVM_DIR/nvm.sh" ]; then
        source "$NVM_DIR/nvm.sh"
    fi
fi

# iTerm2 Shell Integration
if [ -e "$HOME/.iterm2_shell_integration.zsh" ]; then
    source "$HOME/.iterm2_shell_integration.zsh"
fi

# Backup and Update Aliases
alias backup-zshrc="cp ~/.zshrc ~/.zshrc.backup && echo 'Backup created at ~/.zshrc.backup'"
alias update-zsh="source ~/.zshrc && echo 'Reloaded .zshrc settings'"

# To customize prompt, run `p10k configure` or edit ~/.p10k.zsh.
[[ ! -f ~/.p10k.zsh ]] || source ~/.p10k.zsh

🤔 Why Should You Even Care About Git & GitHub?

Imagine this: You’re working on a project, everything is going great, and then—BOOM!—you accidentally delete your code. Or worse, your teammate overwrites your work.

This is where Git and GitHub save the day. 💪

• Git is like a time machine for your code. It helps you track changes, revert mistakes, and collaborate with others without screaming at your screen.

• GitHub is the social media of Git—where you store, share, and collaborate on projects with developers around the world.

Whether you’re a college student, a beginner, or just someone who doesn’t want to lose their code, this cheat sheet is your best friend. Let’s go! 🚀

⚡ Core Git Commands (a.k.a. Your Day-to-Day Lifesavers)

📌 What’s the Difference Between git fetch and git pull?

• git fetch only checks for updates from the remote repo but doesn’t apply them.

• git pull fetches updates and merges them into your local branch automatically.

🌳 Branching Like a Pro

🚀 Why Use Branches?

• Keep your main branch clean and bug-free 🧼

• Work on new features without messing up the main project

• Test things out without affecting the main codebase

🔍 Finding & Fixing Mistakes

😱 What If You Mess Up?

• For small mistakes: git reset <file> moves it back to unstaged.

• For big mistakes: git revert is safer because it doesn’t delete history.

• For catastrophic mistakes: git reflog helps you restore lost commits.

📌 Stashing: When You Need a Quick Save

🚀 When to Use git stash?

• If you need to switch branches quickly without committing unfinished work.

• If your teammate says, “Hey, pull the latest changes first!” but you’re mid-edit.

🌎 GitHub-Specific Commands

🔥 GitHub CLI: Make Life Even Easier

🤝 Collaborating with a Team

🚀 Pro Tips for Git & GitHub

🔥 1. Write Meaningful Commit Messages
Bad: git commit -m "fixed stuff" ❌
Good: git commit -m "Fixed login button alignment issue" ✅

🔥 2. Always Pull Before Pushing
Running git pull origin main before pushing prevents conflicts.

🔥 3. Use .gitignore to Exclude Unnecessary Files
Example .gitignore for Node.js projects:

node_modules/
.env
*.log

🔥 4. Use Aliases for Shortcuts
Speed up your workflow with aliases in ~/.gitconfig:

git config --global alias.co checkout
git config --global alias.cm "commit -m"
git config --global alias.st status

🔥 5. Never Use git reset --hard on Public Branches
It erases commits permanently. If you need to undo, use git revert.

🎯 Final Thoughts

Congratulations! 🎉 You now understand Git & GitHub better than 90% of beginners.

But remember—Git is a skill. The more you use it, the more it makes sense. Don’t be afraid to break things (as long as you know how to fix them 😉).

💡 Your Next Challenge:
Try using Git for all your projects for a week. No file copy-pasting. No “final_final_v3” folders. Just pure Git-powered efficiency.

Happy coding! 🚀👨‍💻

Current Architecture

Frontend Framework

• Next.js: Provides server-side rendering, dynamic routing, and static site generation.

• TypeScript: Replacing JavaScript incrementally to enable better type safety and robust development.

• React: Used for building declarative, reusable UI components.

Deployment and Infrastructure

• Dockerized Containers: Ensure a consistent environment for development and deployment.

• Helm Charts: Manage environment-specific deployments (dev, staging, production) with overrides.

• Node.js: Backend support for APIs and server-side rendering.

Libraries and Dependencies

The project uses several key libraries to enhance functionality and developer productivity:

UI/UX and Components

• @chakra-ui/react: For building accessible, responsive UIs.

• @emotion/react and @emotion/styled: For custom styling.

• Framer Motion: For animations and transitions.

• React Icons: Provides a library of commonly used icons.

Data Visualization

• @nivo/bar, chart.js, and react-chartjs-2: For interactive charts and data visualizations.

• Reactflow: Enables building node-based visualizations like workflows and dependency trees.

• Vis-network: For creating interactive, hierarchical network visualizations.

State Management and Data

• MobX and MobX React: Lightweight, reactive state management.

• @tanstack/react-table: For building feature-rich, performant data tables.

• Axios: Handles HTTP requests with ease.

Utilities and Miscellaneous

• Lodash: For utility functions like deep copying, object manipulation, and array operations.

• Date-fns and Day.js: For date manipulation and formatting.

• Html2pdf.js: To generate PDFs from HTML.

Animations and Special Features

• Tsparticles: Creates interactive particle animations.

• Draft.js and React-draft-wysiwyg: For creating rich-text editors.

• React-to-print: Enables printing React components.

Scripting and Build Tools

• Eslint: For linting and enforcing coding standards.

• Source-map-explorer: Analyzes and visualizes JavaScript bundle sizes.

• TypeScript: Enhances static type-checking and scalability of the codebase.

Codebase Organization

• Mixed Codebase: A combination of JavaScript and TypeScript files due to the ongoing migration.

• Clear Directory Structure:

  • pages/: For route-specific components and server-side rendering logic.

  • components/: For reusable React components.

  • scripts/: Contains deployment and build scripts.

  • configs/: Environment-specific overrides.

Current Challenges

1. JavaScript-to-TypeScript Migration:

   • Status: Approximately 30% of the codebase remains in JavaScript.

   • Challenges: Refactoring legacy modules, external library typings, and managing dynamic imports.

2. Heavy Animations:

   • Drawer and modal animations feel heavy on some lower-spec systems.

   • Current implementations lack GPU optimization.

3. Build Optimization:

   • Dependencies like charting libraries increase the bundle size.

   • Some unused modules contribute to unnecessary overhead.

4. Configuration Complexity:

   • Managing overrides for multiple environments can be error-prone and time-consuming.

Upcoming Modifications

To address these challenges, we plan the following improvements:

1. Complete TypeScript Migration:

   • Migrate legacy JavaScript files while enforcing strict typing.

   • Refactor utilities and APIs for cleaner TypeScript integration.

2. Optimize Animations:

   • Rewrite heavy animations using GPU-accelerated techniques.

   • Simplify animation logic to reduce resource usage.

3. Improve Build Performance:

   • Dynamically import rarely used libraries to reduce initial bundle size.

   • Analyze dependencies with source-map-explorer and remove unused modules.

4. Streamline Configurations:

   • Consolidate environment-specific overrides to minimize redundancy.

   • Refactor Helm charts for better modularity and scalability.

5. Enhance UI/UX:

   • Leverage Chakra UI for improved accessibility and responsiveness.

   • Use @tanstack/react-table for performant and feature-rich data tables.

Conclusion

With a strong foundation built on modern technologies, our project is evolving to meet the needs of both users and developers. By addressing these challenges, we aim to create a robust, maintainable, and high-performing frontend application. This blog series will walk you through each step of this transformation.

Imagine having all your ideas, research, and projects organized and interconnected, allowing you to easily explore and retrieve information. That’s the power of turning Obsidian into a personal wiki. A personal wiki isn’t just a static collection of notes—it’s a living system where information is connected, grows over time, and reflects your learning and development.

In this episode, we’ll take a detailed look at how you can structure your Obsidian vault to act as a personal wiki. You’ll learn how to create central hubs, link related ideas, utilize categories, and harness the power of Obsidian’s Graph View to make your notes more dynamic and interconnected.

Step 1: Understanding What a Personal Wiki Is

A wiki is a network of interlinked notes or pages, organized in a way that allows you to navigate between related concepts seamlessly. Unlike traditional note-taking systems that rely heavily on folders and hierarchical structures, a wiki is based on relationships between notes.

Why Create a Personal Wiki?

• Knowledge Management: A personal wiki helps you keep track of everything you learn, work on, or are interested in. Over time, it becomes a comprehensive resource you can reference and expand.

• Flexibility: With a wiki, you’re not locked into rigid folder structures. Instead, you can organize your notes fluidly by linking them together as your ideas evolve.

• Discovering Connections: By linking notes and using backlinks, you’ll often discover relationships between concepts that weren’t obvious at first. This enhances creativity and understanding.

Step 2: Creating Your Central Hub (Index)

The first step to turning Obsidian into a personal wiki is to create an index note that acts as a central hub for all your notes. This note will serve as the gateway to different areas of your knowledge base.

How to Create an Index Note

1. Create a New Note: Name it something like [[Index]], [[Home]], or [[Dashboard]].

2. List Key Categories: In your index note, create a list of key categories or topics that represent the major areas of your personal wiki.

   • Example Categories:

     • [[Projects]]

     • [[Books and Articles]]

     • [[Personal Development]]

     • [[Learning]]

     • [[Ideas and Inspiration]]

3. Link Category Pages: Each category should link to a new note where you’ll organize subtopics or related notes. For instance:

   • In the [[Projects]] category, create links to individual project notes such as [[Project A]], [[Project B]], etc.

4. Create a Table of Contents (Optional): To make navigation easier, you could structure your index note as a table of contents, outlining the different sections and linking to them directly.

Tips for a Strong Index:

• Keep it Simple: Don’t overload your index with too much information. Focus on broad categories that will help you navigate your vault efficiently.

• Use Keywords: Make sure the titles of categories and notes are easy to search for, so you can quickly access them through Obsidian’s search feature.

• Refine Over Time: Your index isn’t set in stone. As your wiki grows, feel free to add new categories or reorganize existing ones.

Step 3: Linking Notes to Build Connections

The core of any wiki is the interconnectedness of notes. Rather than keeping ideas in isolation, Obsidian allows you to link notes together in ways that reflect how concepts and topics are related.

How to Link Notes in Obsidian

1. Internal Links: Simply type [[ followed by the name of the note you want to link to. Obsidian will provide auto-suggestions based on your existing notes.

   • Example: In your [[Books and Articles]] category, you can link to specific book summaries like [[Atomic Habits]] or [[Deep Work]].

2. Creating New Notes via Links: If the note doesn’t exist yet, typing [[New Note Name]] will automatically create a new note when you click on the link.

   • Example: If you’re writing about a new topic and want to create a note for it, just type [[New Topic]] and Obsidian will create a blank note for you to fill in later.

3. Use Links for Conceptual Connections: Linking isn’t limited to organizing by categories. If you’re writing a note about a project and reference a book that inspired you, link directly to your book note using [[Book Title]].

Backlinks: Viewing Connections

One of the most powerful features of Obsidian is the backlink feature. Backlinks show you where a specific note is referenced elsewhere in your vault.

• Viewing Backlinks: When you open a note, the backlink section (usually at the bottom) shows all the other notes that have linked to the current note.

• Why It’s Important: This helps you see how your ideas connect across different contexts, which can reveal patterns or relationships you may not have consciously realized.

Cross-Linking for Fluid Navigation

Make a habit of cross-linking between notes. For example:

• In your [[Time Management]] note, you could link to methods like [[Pomodoro Technique]] and [[Time Blocking]], allowing you to easily jump between different strategies.

Cross-linking isn’t just for similar topics; it can also be used for contrasting ideas or complementary concepts, creating a more robust understanding.

Step 4: Building Categories and Subcategories

Once you have a basic structure in place, it’s time to build out categories and subcategories to keep things organized.

Creating Broad Categories

Start with high-level categories that encompass the main areas of your life or work.

• Examples of broad categories:

  • [[Learning]]

  • [[Personal Development]]

  • [[Research]]

  • [[Work Projects]]

Creating Subcategories

Within each broad category, create subcategories to help break down the information further.

• Example: Inside your [[Learning]] category, create subcategories for [[Books]], [[Online Courses]], [[Skills]], etc.

Linking from General to Specific

In each category note, link to the subcategories or specific notes.

• Example: In the [[Books]] subcategory, link to individual book notes like [[Deep Work]], [[Sapiens]], and [[Atomic Habits]].

Step 5: Using Graph View for Visual Exploration

The Graph View is one of Obsidian’s standout features, offering a visual representation of how your notes are linked together. As you build your wiki, this becomes an incredibly useful tool for visualizing the relationships between ideas.

How to Use Graph View

1. Open Graph View: Click on the Graph View icon in the left sidebar. You’ll see a web of your notes represented as nodes, with links between them showing their connections.

2. Exploring Connections: You can zoom in on different clusters of notes to explore how ideas are interconnected. This helps you see patterns or gaps in your knowledge.

3. Filters: Use the filter options to narrow down your graph by specific tags or folders. For example, you can filter the graph to only show notes tagged with #research or #projects.

Tips for Using Graph View Effectively

• Focus on Clusters: Look for clusters of related notes, which can give you insight into areas where your ideas are well-developed or need further exploration.

• Spot Gaps: Use the graph to identify areas where more connections could be made. If a note appears isolated, consider how it might relate to other topics in your vault.

• 

Step 6: Integrating Daily Notes into Your Wiki

Daily notes are often used for journaling, quick thoughts, or daily tasks, but they can also be a crucial part of your wiki.

Linking Daily Entries to Projects and Topics

When you mention something in your daily notes, consider linking it to a relevant topic or project in your wiki.

• Example: If you write “Worked on [[Project A]] today” in your daily note, link it directly to the [[Project A]] page to track your work and reference it later.

Using Daily Notes for Incremental Growth

Daily notes allow you to build your wiki incrementally. As you create daily notes, link new ideas or projects back to your core wiki structure. This keeps your knowledge system evolving with your daily work.

Step 7: Regularly Reviewing and Updating Your Wiki

A personal wiki is not a static system. To get the most out of it, regularly review and update your notes.

How to Maintain Your Wiki

1. Review Key Notes: Periodically revisit your main category and project notes. Add new insights, update outdated information, and strengthen connections with new links.

2. Create Summary Notes: For topics that grow large, create summary notes that consolidate key information. This helps you get a quick overview of a subject without sifting through multiple notes.

3. Expand as You Learn: As you read new books, take new courses, or start new projects, continuously add to your wiki. The more connections you create, the more useful your wiki becomes.

Conclusion

By turning Obsidian into your personal wiki, you create a dynamic, interconnected system that grows alongside your knowledge and ideas. Through the use of internal links, categories, backlinks, and the powerful Graph View, your notes evolve from isolated pieces of information into a living web of interconnected thoughts. This approach helps you navigate your ideas more fluidly, discover hidden connections, and retrieve information effortlessly.

Your personal wiki is not a static resource—it's an ever-evolving system that reflects your ongoing learning, projects, and creativity. As you continue adding, linking, and refining your notes, your Obsidian vault will become a powerful second brain, capable of supporting you in your professional and personal pursuits.

In the next episode, we’ll dive into the Zettelkasten Method, a note-taking technique that further enhances this interconnectedness, helping you take your knowledge management to the next level. Stay tuned!

Obsidian is a powerful tool on its own, but its real strength comes from the vast library of plugins available. Plugins allow you to tailor your Obsidian experience to suit your specific needs, whether you're managing projects, writing, or building a personal knowledge base. In this episode, we'll explore some of the most essential plugins that can take your Obsidian workflow to the next level.

Step 1: Installing Plugins

Obsidian offers two types of plugins: Core Plugins and Community Plugins.

1. Enabling Core Plugins:

   • Core Plugins are built-in features of Obsidian. You can enable or disable them based on your needs.

     • Go to Settings > Core Plugins.

     • Toggle on the plugins you want to use, such as Daily Notes, Templates, and Backlinks.

2. Installing Community Plugins:

   • Community Plugins are developed by the Obsidian community and can be installed from the marketplace.

     • Go to Settings > Community Plugins > Browse.

     • Search for the plugins you want, install them, and click Enable.

Step 2: Must-Have Plugins for Productivity

Here’s a list of some of the most useful plugins you can integrate into your Obsidian setup:

1. Dataview:

   • Description: Dataview allows you to query your notes and present the information in tables, lists, or calendar views. It’s perfect for displaying data such as tasks, deadlines, or research.

   • Use Case: Track all notes tagged with #task or #research and display them in an easily viewable format.

2. Calendar Plugin:

   • Description: The Calendar Plugin gives you a visual calendar to navigate your daily notes, making it easy to track progress over time.

   • Use Case: Quickly view and manage your daily notes from a calendar interface. You can create future notes and plan ahead as well.

3. Kanban Plugin:

   • Description: This plugin helps you organize your tasks visually using a Kanban board. You can easily track tasks through different stages like “To Do,” “In Progress,” and “Completed.”

   • Use Case: Manage tasks or projects by creating columns for different stages, and move tasks through the workflow with drag and drop functionality.

4. Templater:

   • Description: Templater is a more advanced template manager than the default Templates plugin. It allows you to create dynamic templates with variables, which can significantly speed up your note creation process.

   • Use Case: Create dynamic templates for meeting notes, daily logs, or research. You can automatically generate dates, titles, and other fields with this plugin.

5. Excalidraw:

   • Description: Excalidraw is a powerful drawing tool integrated into Obsidian. It allows you to create hand-drawn-style diagrams directly in your notes.

   • Use Case: Use Excalidraw for brainstorming, mind mapping, or creating visual models for projects and ideas.

6. QuickAdd:

   • Description: QuickAdd allows you to quickly add notes, tasks, or templates with a simple command. This is useful for capturing ideas or tasks without breaking your workflow.

   • Use Case: Use it to capture tasks or meeting notes on the fly without needing to manually create new notes.

7. Task Plugin:

   • Description: The Task Plugin extends the functionality of Obsidian’s built-in task system, allowing you to add due dates, recurring tasks, and filters.

   • Use Case: Manage your tasks with due dates and filters, and track recurring tasks easily within your notes.

8. Advanced Tables:

   • Description: This plugin simplifies the creation of tables in Markdown, making it easier to format and edit tables directly within your notes.

   • Use Case: Create well-organized tables for tracking tasks, research, or project data without dealing with complex Markdown syntax.

9. Periodic Notes:

   • Description: This plugin is perfect for journaling or keeping track of notes on a daily, weekly, or monthly basis. It automates the creation of daily, weekly, and monthly notes.

   • Use Case: Automate your journaling or project tracking with a system that generates new notes for specific time periods.

10. Natural Language Dates:

• Description: This plugin allows you to use natural language to create dates in your notes. You can type phrases like "next Monday" or "in 3 days" and Obsidian will convert them to actual dates.

• Use Case: Quickly set task due dates or create reminders using natural language.

Step 3: Enhancing Workflow with More Plugins

Here are a few more plugins that can add significant value to your workflow:

11. Obsidian Git:

• Description: This plugin lets you sync your notes with a Git repository. Perfect for users who want to version-control their notes or collaborate with others.

• Use Case: Sync your notes across devices using Git, providing an automatic backup and version control system.

12. Hover Editor:

• Description: This plugin allows you to preview and edit notes in a popup window without navigating away from your current note.

• Use Case: Quickly check and edit linked notes without interrupting your flow.

13. Omnisearch:

• Description: Omnisearch adds powerful search functionality to Obsidian, enabling you to search within all your notes more efficiently.

• Use Case: Quickly find notes, keywords, or tags using advanced search features across your entire vault.

14. Workspaces:

• Description: Workspaces lets you save and restore specific layouts in Obsidian, allowing you to switch between different workflows (such as research mode or writing mode) with ease.

• Use Case: Create different workspaces for writing, task management, or research, and switch between them depending on what you’re working on.

Step 4: Managing Plugins Efficiently

To make sure your Obsidian experience stays smooth and fast, it’s important to manage your plugins wisely:

1. Deactivate Unused Plugins:

   • If you don’t need certain plugins anymore, disable or uninstall them to keep Obsidian running smoothly.

2. Update Plugins Regularly:

   • Go to the Community Plugins section and check for updates to keep your plugins up-to-date and working efficiently.

Step 5: Advanced Use - Building Custom Plugins

For developers or power users, Obsidian allows you to create your own custom plugins:

1. Getting Started:

   • Use TypeScript or JavaScript to build your own custom plugins by utilizing the Obsidian API.

2. Custom Use Cases:

   • If you need specific workflows or integrations, building a custom plugin may be the perfect solution for automating tasks or adding specialized features.

Conclusion

Plugins are what make Obsidian incredibly versatile, allowing you to turn it into a productivity powerhouse. From task management and visual calendars to advanced note querying, the range of plugins lets you customize Obsidian to suit your workflow. Whether you’re writing, researching, or managing projects, there’s a plugin to enhance your experience.

In the next episode, we’ll explore how to turn Obsidian into your personal wiki, creating a fully interconnected knowledge base. Stay tuned for more!

Taking notes isn’t just about capturing ideas; it’s also about tracking daily thoughts, tasks, and progress. Daily Notes in Obsidian allow you to create a new note for each day, helping you manage your tasks, journal your thoughts, and link ideas together as you go. In this episode, we’ll explore how to use Daily Notes and integrate simple task management into Obsidian to stay organised and productive.

Step 1: Setting Up Daily Notes

The Daily Notes plugin is a built-in feature in Obsidian that creates a new note for each day. Here’s how to set it up:

1. Enabling the Daily Notes Plugin:

   • Go to Settings in the bottom left corner of the Obsidian window.

   • Navigate to the Core Plugins section.

   • Find Daily Notes in the list and toggle it on.

   • 

2. Creating Your First Daily Note:

   • Once the plugin is enabled, you’ll see a new calendar icon on the left sidebar.

   • Click on this icon, and Obsidian will automatically create a new note for today’s date. The note will be named after the current date, for example, 2024-10-12.

   • 

3. Adding Content to Your Daily Note:

   • You can write anything in your daily note—ideas, tasks, goals, or even a quick journal entry.

   • Each day, a new note will be created, and over time, you’ll have a series of dated notes tracking your daily activities and thoughts.

Step 2: Using Daily Notes to Track Tasks

Daily Notes are a great way to keep track of tasks and to-dos. Here’s how to use Markdown formatting to create a simple task list:

1. Creating a Task List:

   • Inside your daily note, type - [ ] to create a task. For example:

     • - [ ] Finish reading Obsidian documentation

     • - [ ] Start working on new blog post

     • 

2. Marking Tasks as Complete:

   • When you finish a task, simply replace [ ] with [x] to check it off. For example:

     • - [x] Finish reading Obsidian documentation

       

3. Using Tags to Track Specific Tasks:

   • You can use tags like #priority or #urgent to categorize and track your tasks across notes. This way, you can later search for tasks by their priority or category.

   • 

Step 3: Linking Daily Notes to Projects and Ideas

Daily Notes aren’t just standalone records—they can be connected to other notes in your vault. Here’s how to use links to connect your daily thoughts with larger projects:

1. Linking to Other Notes:

   • If you’ve written about a project or idea in another note, you can easily link to it from your Daily Note. Just type [[ and the name of the note to create a link. For example:

     • “Worked on [[Project A]] for 2 hours.”

     • 

2. Tracking Progress Over Time:

   • By linking related daily entries to ongoing projects, you can create a timeline of your work and see how your ideas evolve over time.

3. Backlinks in Daily Notes:

   • As you link daily entries to other notes, you’ll see backlinks that show how often you’ve referred to certain projects or ideas, giving you a clearer view of what you’re focusing on.

Step 4: Using the Calendar Plugin for Task and Note Management

For those who prefer a visual calendar to track daily notes, the Calendar Plugin is a great addition. Here’s how to use it:

1. Installing the Calendar Plugin:

   • Go to Settings > Community Plugins.

   • 

   • 

   • Click of browse

   • Search for Calendar and install it.

   • 

   • Once installed, you’ll see a calendar icon on the sidebar where you can easily navigate through your daily notes.

   • 

2. Viewing Past and Future Notes:

   • The Calendar Plugin shows a monthly view of all your notes, allowing you to click on any date to see the note created on that day.

   • You can also create future daily notes ahead of time to plan tasks or ideas.

Step 5: Managing Projects with Daily Notes and Kanban

If you want to expand your task management capabilities, Obsidian supports a Kanban Plugin for organizing your tasks into boards. Here’s a brief overview:

1. Installing the Kanban Plugin:

   • Go to Settings > Community Plugins.

   • Search for Kanban and install it.

2. Creating a Kanban Board:

   • Create a new note and type kanban to start building your board. You can create lists for tasks like “To Do,” “In Progress,” and “Completed.”

   • You can link tasks from your Daily Notes into the Kanban board to track their status.

Using a combination of Daily Notes and the Kanban board, you can easily manage tasks on both a daily and project level.

Conclusion

Daily Notes and task management in Obsidian give you a simple yet effective way to organize your day-to-day activities, track tasks, and link ideas to long-term projects. By using Daily Notes, task lists, and integrating features like the Calendar and Kanban plugins, you can create a powerful personal productivity system within Obsidian.

In the next episode, we’ll explore Plugins in Obsidian, and how they can further enhance your workflow and note-taking experience. Stay tuned as we continue to build your second brain!

Once you've set up your vault and started creating notes in Obsidian, the next step is learning how to organise them. Obsidian makes it easy to connect your notes through internal links and categorise them using tags. These two powerful features will help you create a well-organised system where your ideas are easily accessible and interconnected.

In this episode, I’ll show you how to use links and tags to keep your notes organised and make the most out of Obsidian’s unique capabilities.

Step 1: Linking Notes in Obsidian

One of the key features that sets Obsidian apart from other note-taking apps is the ability to link notes together. This helps you create a web of connected ideas instead of having isolated notes. Here's how to do it:

1. Creating a Link to Another Note

   • While you're writing in one note, type [[ and then start typing the name of the note you want to link to. Obsidian will show a list of suggestions based on your vault’s existing notes.

   • Once you see the note you want to link to, click on it, or press enter. Obsidian will automatically create the link.

   • 

2. Creating a New Note with a Link

   • If the note you want to link to doesn’t exist yet, don’t worry! Obsidian allows you to create new notes on the fly.

   • Just type [[New Note Name]] and hit enter.

     • 

   • A new note will automatically be created with that title while opening the link.

     • 

3. Navigating Linked Notes

   • Once you have linked notes, you can click on any link to jump to the connected note. This makes it easy to navigate between related ideas.

By linking your notes, you can create relationships between ideas and easily move through your thoughts as they connect.

Step 2: Using Backlinks

Backlinks are another powerful feature in Obsidian that help you see which notes are referring to the current note. This way, you can track relationships between notes from multiple directions.

• View Backlinks: At the bottom of each note, you’ll find a section called Backlinks. This shows you all the other notes that link to the current note.

• 

Backlinks provide a deeper layer of organisation by showing you connections that you might have forgotten about, helping you rediscover valuable information.

Step 3: Organising with Tags

Tags are a simple but effective way to categorise your notes. They allow you to quickly group related notes without needing a strict folder structure.

1. How to Add Tags

   • To add a tag, simply type # followed by the tag name anywhere in your note. For example, #research or #project.

   • 

2. Benefits of Tags

   • Tags allow you to quickly filter and find notes across your entire vault. If you’re working on multiple projects or themes, you can use tags to categorise your notes by topic, priority, or status.

3. Finding Tagged Notes

   • You can easily search for tags by using the search bar or clicking on a tag in any note to pull up all notes that share the same tag.

   • 

Tags are flexible and can be applied across various topics, projects, or ideas. They provide an additional layer of organisation without locking you into a rigid structure.

Combining Links and Tags for Maximum Organisation

Using links and tags together will help you build a more organised and dynamic knowledge base in Obsidian. Here’s how to make the most out of them:

• Linking Related Notes: As you create more notes, think about how they connect. For example, if you're working on multiple projects, link notes within the same project so you can jump between them easily.

• Tagging Notes by Topic: Use tags to categorise your notes by topic or type. For example, if you’re researching multiple topics, you could tag notes as #research, #ideas, or #tasks to easily sort and filter them.

With both features combined, Obsidian will become a powerful tool for managing all your ideas in a seamless, interconnected way.

Advanced Tip: Graph View for Visual Organisation

One of Obsidian’s standout features is the Graph View, which gives you a visual representation of how your notes are connected. As you start linking and tagging notes, your graph will grow, showing clusters of ideas and their relationships.

• How to Use Graph View: Click the Graph View button on the left sidebar. You’ll see a web of all your linked notes, with each note represented as a node and each link as a line between nodes.

• Zooming In: You can click on any node to zoom in and see its connections more closely, helping you find hidden relationships between your ideas.

• 

The Graph View is an excellent way to explore your notes visually, making connections easier to spot.

Conclusion

By using links, backlinks, and tags, you’ll transform your Obsidian vault from a collection of random notes into a well-organised network of interconnected ideas. Links let you jump between related notes, tags help you categorise content across your vault, and the Graph View provides a visual map of your entire knowledge base.

In the next episode, we’ll dive into Daily Notes and Task Management, exploring how you can track your daily thoughts and tasks within Obsidian. Stay tuned and continue building your second brain with these powerful organisational tools!

We live in a world full of information, and keeping track of everything can be tough. If you like taking notes or organising your thoughts, Obsidian is a tool that can help. It allows you to create and link notes together, turning them into a personal knowledge base. In this article, I’ll show you how to get started with Obsidian - from installing it to making your first notes.

What is Obsidian?

Obsidian is a note-taking app that uses Markdown files. Markdown is a simple way to format text. The best thing about Obsidian is that you can easily link your notes together, helping you organise ideas and create a network of connected information - like a “second brain”!

Advanced Features

Obsidian is more than just a simple note-taking app. Once you're comfortable with the basics, there are some advanced features you can explore to enhance your productivity and knowledge management:

• Graph View: A visual map that shows how all your notes are connected. It helps you see patterns and relationships between ideas.

• Custom Plugins: Obsidian allows you to install community plugins to add new functionalities, such as task management, note tracking, or even integrating your notes with other tools.

• Templates: Speed up your note creation with templates for frequently used note formats. This is great for consistency and saving time.

• Backlinks: Automatically see all notes that link to the current note, helping you discover connections between your ideas.

• Sync and Mobile Access: You can sync your notes across devices, making it easy to access them on the go using Obsidian Mobile.

These features make Obsidian a powerful tool for anyone who wants to take their note-taking and knowledge management to the next level.

Potential Use Cases and Benefits of Using Obsidian

Obsidian isn’t just a simple note-taking app—it’s highly versatile and can be adapted for a variety of purposes. Here are some common use cases that showcase its benefits:

• Personal Knowledge Base: Obsidian lets you organize notes and link them together, creating a connected system that grows with your knowledge. Whether you're studying, doing research, or just trying to manage your thoughts, it helps build a repository you can refer to at any time.

• Project Management: With plugins and task-tracking features, you can use Obsidian to manage personal or professional projects. You can easily create project notes, track tasks, and link ideas or resources together.

• Creative Writing: Writers can benefit from Obsidian by organizing characters, plotlines, and research. Linking notes allows you to visualize relationships between different aspects of your story, helping you stay organized and inspired.

• Daily Journaling: Using Obsidian’s Daily Notes feature, you can capture your thoughts, track goals, and reflect on your day, linking your journal entries to relevant notes for future reference.

• Research and Zettelkasten: If you’re into deeper knowledge work, Obsidian works perfectly for building a Zettelkasten system, where you can break down complex ideas into smaller “atomic” notes and link them together.

By using Obsidian, you’re not just creating standalone notes—you’re building an ecosystem of ideas that you can grow and refine over time.

Step 1: How to Install Obsidian

Here’s how to install Obsidian:

1. Visit the Obsidian website.

2. Click Download and choose the version for your computer (Windows, macOS, or Linux).

3. After the download finishes, install it like any other program.

4. Open Obsidian once it’s installed.

Now, you’ll see a screen asking you to set up a vault.

Step 2: Setting Up Your First Vault

In Obsidian, a vault is a folder on your computer where all your notes are stored. Here’s how to create one:

1. Click on Create a new vault.

2. Give your vault a name, like “My Notes.”

3. Pick a location on your computer to save it.

4. Click Create.

Now your vault is ready!

Step 3: Making Your First Note

Let’s make your first note:

1. On the left side of the screen, click the New Note button (it looks like a piece of paper with a edit sign).

2. A blank note will appear. Click where it says “Untitled” and give it a name, like “My First Note.”

3. Start typing in the note. You can write anything you like!

Step 4: Linking Your Notes

One of the coolest features of Obsidian is linking notes together. Here’s how you do it:

1. Make a second note by clicking the New Note button again. Name this note “Second Note.”

2. In this note, type something like “This is my second note.”

3. To link this note to your first note, type [[My First Note]] in the body of “Second Note.”

4. Click on the link you just made, and it will take you to “My First Note.”

You’ve now linked two notes together! This is how you build a network of connected ideas in Obsidian.

Step 5: Basic Formatting with Markdown

Obsidian uses Markdown to format your text. Here are some simple Markdown commands:

• Bold text: **This text is bold**

• Italic text: *This text is italic*

• Headings: Add # at the start of the line for a big heading (# Heading), ## for a smaller heading, and ### for an even smaller heading.

• Bullet points: Start a line with - like this:

  • - First item

  • - Second item

Conclusion

Obsidian is more than just a note-taking app; it’s a powerful tool that helps you organize your thoughts, connect ideas, and manage information in a meaningful way. In this article, we explored how to get started—from installing the app to creating your first notes and linking them together. We also touched on the basics of Markdown formatting, a key part of making your notes easy to read and structure.

Once you're comfortable with the basics, the potential use cases of Obsidian are vast - whether it's building a personal knowledge base, managing projects, or even creative writing.

As you continue to explore Obsidian, you'll find more ways to make it work for you. The possibilities are endless, and with time, Obsidian can become your go-to tool for organizing everything you know.

So, why wait? Start today, create your first vault, and discover how Obsidian can help you manage your thoughts, ideas, and projects more effectively!

Here are some key features and functionalities of GitHub Actions:

1. Workflow Automation: GitHub Actions allows you to define custom workflows using YAML files in your repository. Workflows are composed of one or more jobs, and each job can consist of multiple steps. These workflows can be triggered by events such as code pushes, pull requests, or external events.

2. Continuous Integration (CI): You can set up CI workflows to automatically build and test your code whenever changes are pushed to your repository. GitHub Actions provides a range of virtual machine environments and containers for running these tasks.

3. Continuous Deployment (CD): With GitHub Actions, you can automate the deployment of your applications to various hosting platforms or cloud services like AWS, Azure, or GitHub Pages. This allows you to release new versions of your software with confidence.

4. Event-Driven Triggers: GitHub Actions can be triggered by various events, including code commits, pull requests, issue comments, and custom webhooks. You can define which events should trigger specific workflows.

5. Custom Actions: You can create reusable actions to encapsulate common tasks or steps in your workflows. These actions can be shared with the GitHub community or used privately within your organization.

6. Marketplace: GitHub provides a marketplace where you can discover and use pre-built GitHub Actions created by the community to integrate with different services and tools.

7. Secrets Management: GitHub Actions allows you to securely store and use sensitive information, such as API tokens and credentials, as secrets in your workflows.

8. Matrix Builds: You can set up matrix builds to test your code against multiple versions of programming languages, dependencies, or platforms in parallel.

GitHub Actions simplifies and streamlines the automation of your software development processes, helping you save time and ensure the quality of your code. It is tightly integrated with GitHub repositories, making it a popular choice for many development teams for managing their CI/CD pipelines.

Components of Github Action

1. Workflow: A workflow is a set of automated tasks defined in a YAML file (typically named main.workflow or .github/workflows/*.yml) in your repository. Workflows define the actions to be taken when specific events occur, such as code pushes, pull requests, or scheduled jobs.

2. Jobs: A workflow is composed of one or more jobs, each of which represents a separate set of tasks that can run concurrently on the same runner (execution environment). Jobs are defined within the jobs section of the workflow YAML file.

3. Steps: Jobs are made up of one or more steps, which are individual units of work within a job. Each step can execute a specific action, script, or command. Steps are defined within the steps section of a job and are executed sequentially.

4. Actions: Actions are reusable units of code that can be included in your workflows to perform specific tasks or actions. Actions can be defined in your repository or sourced from the GitHub Marketplace or other repositories. You can use pre-built actions or create custom actions to suit your needs.

5. Runners: Runners are the execution environments where your workflows run. GitHub provides virtual environments (GitHub-hosted runners) for common platforms, including Linux, macOS, and Windows. You can also set up your own self-hosted runners for more customized workflows or for environments that GitHub does not provide.

6. Events: Events are specific occurrences that trigger workflows. These events can include code pushes, pull requests, issue comments, and more. Workflows are configured to run in response to one or more specific events.

7. Workflow Files: Workflow files are written in YAML format and define the structure and behavior of your workflows. These files are stored in the .github/workflows/ directory in your repository and are used to specify which events trigger the workflow, the jobs to run, and the steps within those jobs.

8. Contexts: GitHub Actions provides various context variables that contain information about the event, repository, and workflow run. You can access these context variables in your workflow to make decisions or customize actions based on the current context.

9. Secrets: Secrets are encrypted environment variables that you can store in your repository's settings. These secrets can be used in your workflow to securely store sensitive information such as API keys, access tokens, and passwords.

10. Artifacts: Artifacts are files or data produced by a workflow that you want to persist or pass between jobs. You can use artifacts to store build outputs, test results, or any other data that needs to be retained for further processing.

11. Caching: Caching allows you to store and reuse dependencies or build artifacts between workflow runs to improve build performance. You can specify caching in your workflow to speed up repetitive tasks.

12. Environment Variables: You can define environment variables within your workflow to store configuration settings or pass data between steps.

13. Workflow Status: GitHub Actions provides a visual representation of the status of your workflows, jobs, and steps within the GitHub repository interface. You can monitor the progress and outcome of your workflows directly on GitHub.

Sample Workflow

GitHub Actions uses YAML syntax to define the workflow. Each workflow is stored as a separate YAML file in your code repository, in a directory named .github/workflows.

You can create an example workflow in your repository that automatically triggers a series of commands whenever code is pushed. In this workflow, GitHub Actions checks out the pushed code, installs the bats testing framework, and runs a basic command to output the bats version: bats -v.

1. In your repository, create the .github/workflows/ directory to store your workflow files.

2. In the .github/workflows/ directory, create a new file called learn-github-actions.yml and add the following code.

   YAML

    name: learn-github-actions
    run-name: ${{ github.actor }} is learning GitHub Actions
    on: [push]
    jobs:
      check-bats-version:
        runs-on: ubuntu-latest
        steps:
          - uses: actions/checkout@v4
          - uses: actions/setup-node@v3
            with:
              node-version: '14'
          - run: npm install -g bats
          - run: bats -v
   

3. Commit these changes and push them to your GitHub repository.

Your new GitHub Actions workflow file is now installed in your repository and will run automatically each time someone pushes a change to the repository. To see the details about a workflow's execution history, see "Viewing the activity for a workflow run."

This GitHub Actions workflow is named "learn-github-actions." It is designed to check the version of the Bats testing framework and verify that it's correctly installed in the GitHub Actions runner environment. Here's a breakdown of the workflow:

1. Name and Run Name:

   • name: learn-github-actions: This sets the name of the workflow to "learn-github-actions."

   • run-name: ${{ github.actor }} is learning GitHub Actions: The run-name specifies a dynamic name for each workflow run, incorporating the GitHub actor's username (the user or bot triggering the workflow) to make each run's name unique.

2. Trigger Event:

   • on: [push]: This workflow is triggered by the push event, meaning it will run whenever code is pushed to the repository.

3. Jobs:

   • The workflow defines a single job named "check-bats-version."

   • runs-on: ubuntu-latest: This job runs on the latest version of the Ubuntu runner provided by GitHub Actions.

4. Steps:

   • uses: actions/checkout@v4: This step checks out the code from the repository using the actions/checkout action. It fetches the repository's code so that the workflow can work with it.

   • uses: actions/setup-node@v3: This step sets up a Node.js environment using the actions/setup-node action. It specifies Node.js version 14 as the desired version.

   • run: npm install -g bats: This step installs the Bats testing framework globally using npm. The -g flag ensures that Bats is available system-wide.

   • run: bats -v: Finally, this step runs the bats -v command to check the version of Bats installed. It verifies that Bats is correctly installed in the GitHub Actions runner environment and prints the version.

In summary, this workflow is triggered by code pushes to the repository, and its main purpose is to check the version of the Bats testing framework to ensure it's available for use in subsequent testing steps. The workflow is informative as it includes the actor's name in its run name, making it clear who initiated each workflow run.

More detailed explanation is give in https://docs.github.com/en/actions/learn-github-actions/understanding-github-actions#create-an-example-workflow

What kind of Events can we configure

GitHub Actions can be triggered using a variety of events that occur within a GitHub repository. Some of the common events that can trigger GitHub Actions workflows include:

1. Push Events: These events are triggered when code is pushed to a repository, such as pushing to a specific branch or creating a new branch.

2. Pull Request Events: Actions can be triggered when pull requests are opened, updated, or closed. You can also specify conditions based on which pull requests trigger workflows, such as labels or branches.

3. Issue Events: Actions can be triggered when issues are created, updated, or closed. Like with pull requests, you can specify conditions based on labels or other attributes.

4. Release Events: When a new release is published for a repository, you can trigger actions to perform tasks like building and publishing release assets.

5. Scheduled Events: You can schedule actions to run at specific times or intervals using cron syntax. This is useful for tasks like automated backups or regular maintenance.

6. Webhooks: You can configure custom webhooks to trigger actions when specific events occur, even events outside of the standard GitHub event types.

7. Deployment Events: Actions can be triggered when a deployment event occurs, such as deploying code to a specific environment.

8. Workflow Dispatch: You can manually trigger workflows using the GitHub web interface or the GitHub API. This is useful for one-off or manual tasks.

9. External Events: GitHub Actions can also be triggered by external events using the repository_dispatch event. This allows you to trigger actions from external systems or services.

10. Repository and Organization Events: Actions can also be triggered by events related to the repository or organization itself, such as when a repository is archived or unarchived.

In Part 1, we successfully set up MITM Proxy to intercept network requests from a mobile app running on an Android/iOS device. We learned how to:

✅ Install MITM Proxy and start a proxy server.
✅ Configure proxy settings on a real device/emulator.
✅ Intercept HTTP & HTTPS requests using a MITM CA Certificate.

🚀 That was fun, but now let’s take it to the next level!

🔥 What’s Next?

We don’t just want to view network logs—we want to capture them programmatically in our automation framework.

And for that, we’ll use MITM Proxy’s Java Client!

🤖 What is the MITM Proxy Java Client?

The MITM Proxy Java Client (mitmproxy-java) acts as a bridge between MITM Proxy and your Java-based automation framework.

💡 Here’s how it works:

✅ MITM Proxy starts a WebSocket server.
✅ A Python plugin inside MITM Proxy sends network traffic to the Java client.
✅ The Java client captures and stores network requests for analysis.

With this setup, we can:
🔍 Capture API calls made by the mobile app.
📄 Save network logs for debugging.
🔗 Attach logs to test reports.

⚙️ Step 1: Install the Required Dependencies

📌 Prerequisites

Before setting up the Java client, make sure you have:

1️⃣ MITM Proxy v9+ installed and working.
2️⃣ Python 3.6+ (MITM Proxy uses async WebSockets).
3️⃣ WebSockets module installed:

pip3 install websockets

📌 Add MITM Proxy Java Dependency to Your Project

If you’re using Maven, add this dependency to your pom.xml:

<dependency>
  <groupId>io.appium</groupId>
  <artifactId>mitmproxy-java</artifactId>
  <version>2.0.2</version>
</dependency>

🚨 Note: The latest version is not yet available in the official repository, so you may need to clone the source code and build your own JAR.

📂 Step 2: Integrate MITM Proxy Java Client in Your Framework

🕒 Step 2.1: Create a Class to Store Intercepted Messages

To store network logs with timestamps, create InterceptedMessages.java:

import io.appium.mitmproxy.InterceptedMessage;
import lombok.Getter;
import lombok.Setter;
import lombok.experimental.Accessors;

import java.util.Date;

/**
 * Stores intercepted message along with timestamp.
 */
public class InterceptedMessages {
    @Accessors(chain = true)
    @Getter@Setter
    private Date timestamp;

    @Accessors(chain = true)
    @Getter@Setter
    private InterceptedMessage interceptedMessage;
}

🚀 Now every intercepted request will be saved with a timestamp!

🛠 Step 2.2: Add a Handler to Start & Stop MITM Proxy

Now, let’s create MITMProxy.java to:
✅ Start the proxy listener.
✅ Capture network traffic.
✅ Stop the proxy when needed.

import io.appium.mitmproxy.InterceptedMessage;
import io.appium.mitmproxy.MitmproxyJava;
import lombok.Getter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.concurrent.TimeoutException;

/**
 * MITM Proxy Utility for Capturing Network Logs in Automation Framework.
 */
public class MITMProxy {
    @Getter
    private final List<InterceptedMessages> networkCalls = new ArrayList<>();

    private static MITMProxy proxyInstance = null;
    private MitmproxyJava proxy;

    // Singleton Pattern to Ensure Single Instance
    private MITMProxy() {
        startProxyListener();
    }

    public static MITMProxy getProxy() {
        if (proxyInstance == null)
            proxyInstance = new MITMProxy();
        return proxyInstance;
    }

    /**
     * Starts MITM Proxy and Listens for Network Traffic
     */
    private void startProxyListener() {
        System.out.println("🚀 Starting MITM Proxy Listener...");

        List<String> extraMitmproxyParams = Arrays.asList("--showhost", "<domain-name-filter>");
        int mitmproxyPort = 8090;

        this.proxy = new MitmproxyJava(getMitmDumpPath(), (InterceptedMessage message) -> {
            InterceptedMessages interceptedMessage = new InterceptedMessages()
                    .setTimestamp(new Date())
                    .setInterceptedMessage(message);
            networkCalls.add(interceptedMessage);

            // Log each intercepted message
            System.out.println("🔍 Captured Network Request at: " + interceptedMessage.getTimestamp());
            System.out.println("📡 Request Details: " + message);

            return message;
        }, mitmproxyPort, extraMitmproxyParams);

        try {
            // Kill existing process on the same port if running
            String processId = ProcessExecutor.executeCommandSync("lsof -t -i:" + mitmproxyPort + " -sTCP:LISTEN").trim();
            if (!processId.isEmpty())
                ProcessExecutor.executeCommandSync("kill -9 " + processId);

            this.proxy.start();
        } catch (IOException | TimeoutException e) {
            throw new RuntimeException("❌ Failed to Start Proxy: " + e.getMessage());
        }

        System.out.println("✅ Proxy Listener Started Successfully!");
    }

    /**
     * Retrieves MITM Dump Path
     */
    private String getMitmDumpPath() {
        String result = ProcessExecutor.executeCommandSync("whereis mitmdump");
        return result.split("mitmdump: ")[1].split(" ")[0].trim();
    }

    /**
     * Stops MITM Proxy
     */
    public void stopProxyListener() {
        System.out.println("🛑 Stopping MITM Proxy Listener...");
        try {
            this.proxy.stop();
        } catch (InterruptedException e) {
            throw new RuntimeException("❌ Failed to Stop Proxy: " + e.getMessage());
        }
        System.out.println("✅ Proxy Listener Stopped Successfully!");
    }

    /**
     * Prints All Captured Network Logs
     */
    public void printCapturedLogs() {
        System.out.println("📜 Printing Captured Network Logs...");

        if (networkCalls.isEmpty()) {
            System.out.println("⚠️ No network requests were intercepted.");
            return;
        }

        for (InterceptedMessages msg : networkCalls) {
            System.out.println("⏳ Captured Request at: " + msg.getTimestamp());
            System.out.println("📡 Request Details: " + msg.getInterceptedMessage());
            System.out.println("--------------------------------------------------");
        }
    }
}

🔥 What Does This Class Do?

✅ Automatically starts MITM Proxy when called.
✅ Captures every intercepted request and stores it with a timestamp.
✅ Prevents port conflicts by killing any existing process on the same port.

🚀 Step 3: Start Capturing Network Logs

🎬 Start the Proxy

MITMProxy.getProxy();

👉 This starts the MITM Proxy and begins capturing network requests.

📄 Fetch Intercepted Logs

networkLogMessage = MITMProxy.getProxy().getNetworkCalls();

👉 This retrieves all captured network logs, which can be saved or attached to reports.

🛑 Stop the Proxy

MITMProxy.getProxy().stopProxyListener();

👉 This stops the proxy when tests are complete.

🔍 Verifying Captured Logs

Once your tests have run, print the captured logs to verify that requests are being intercepted:

for (InterceptedMessages msg : MITMProxy.getProxy().getNetworkCalls()) {
    System.out.println("Captured Request at: " + msg.getTimestamp());
    System.out.println("Request Details: " + msg.getInterceptedMessage());
}

🎉 Now you can capture and analyze every network request in your tests!

🎯 What’s Next?

✅ We can now intercept API calls from our mobile automation framework! 🎯

But what if we need to store these logs for later analysis? 🤔

👉 In Part 3, we’ll:
✅ Save network logs to files for debugging.
✅ Attach logs to automation test reports.
✅ Filter out unwanted noise from logs.

Stay tuned for Part 3! 🚀🔥

💬 Questions? Drop a comment below!