############################################################
#                                                          #
#     anamikadev@blogs:~$ ls -lah                          #
#     total 42K                                            #
#     drwxr-xr-x 11 root root 4.0K Jul 25 2025             #
#                                                          #
#     Welcome to the Knowledge Vault — Explore below     #

#                                                          #
############################################################
$ tree ~/var/log/notes/
~/var/log/notes/
├── ebpf-engineering/        # High-performance kernel observability with BPF
│   ├── learn/
│   │   └── ebpf-learning-path.md         # Structured journey through eBPF
│   └── read/
│       ├── intro-to-ebpf.md              # What, Why, and How of eBPF
│       ├── tracing-vs-monitoring.md      # Real-time vs after-the-fact
│       └── write-your-first-ebpf.md      # Hands-on tracepoint programming
├── kernel-os/               # Core Linux internals — memory, syscalls, etc.
│   ├── learn/
│   │   └── kernel-guide.md               # From memory layout to syscall tracing
│   └── read/
│       ├── memory-paging.md              # Virtual memory explained
│       ├── syscall-flow.md               # User to kernel transitions
│       └── kernel-debugging.md           # Tools like printk, ftrace, and more
├── system-programming/      # Working close to the metal — C, processes, pipes
│   ├── learn/
│   │   └── sysprog-guide.md              # Essential skills for systems dev
│   └── read/
│       ├── linux-signals.md              # SIGINT, SIGTERM, and signal handlers
│       ├── file-descriptors.md           # Everything is a file (almost)
│       └── fork-vs-thread.md             # Process vs thread: trade-offs
├── containers-runtime/      # Namespaces, cgroups, OCI explained
│   ├── learn/
│   │   └── container-internals.md        # How containers really work
│   └── read/
│       ├── cgroups-deep-dive.md          # CPU, memory limits & isolation
│       ├── what-is-container.md          # The container abstraction
│       └── containerd-vs-docker.md       # Runtime wars, simplified
├── kubernetes/              # Schedulers, services, configs, and chaos
│   ├── learn/
│   │   └── kubernetes-101.md             # Pods, Deployments, Services
│   └── read/
│       ├── kube-networking.md            # How traffic flows in K8s
│       ├── pod-lifecycle.md              # From creation to eviction
│       └── service-mesh.md               # Sidecars, Envoy, and Istio
├── observability/           # See what your systems are doing
│   ├── learn/
│   │   └── otel-pipeline.md              # Build a telemetry pipeline
│   └── read/
│       ├── metrics-vs-logs.md            # What to emit and when
│       ├── tracing-in-prod.md            # Debug prod without downtime
│       └── grafana-prometheus.md         # Visualizing with open-source tools
├── ci-cd/                   # Automating builds, tests, and delivery
│   ├── learn/
│   │   └── ci-cd-pipeline.md             # GitOps, pipelines, and best practices
│   └── read/
│       ├── github-actions.md             # CI as code for GitHub repos
│       ├── terraform-deploy.md           # Infra as code in the pipeline
│       └── helm-cd-flows.md              # K8s CD with Helm and Argo
├── golang/                  # Concurrency, interfaces, tooling, idioms
│   ├── learn/
│   │   └── go-learning-path.md           # Learn Go from syntax to goroutines
│   └── read/
│       ├── interfaces.md                 # Duck typing, Go-style
│       ├── goroutines-vs-threads.md      # Concurrency made simple
│       └── go-modules.md                 # Dependency management in Go
├── c-programming/           # The language of operating systems
│   ├── learn/
│   │   └── c-learning-path.md            # C from basics to systems-level
│   └── read/
│       ├── pointers-deep-dive.md         # What makes C powerful (and risky)
│       ├── structs-and-unions.md         # Organizing memory
│       └── memory-management.md          # malloc, free, and pitfalls
├── system-design/           # Architecting scalable, resilient systems
│   ├── learn/
│   │   └── sysdesign-primer.md           # Foundational concepts and diagrams
│   └── read/
│       ├── load-balancing-strategies.md  # From round-robin to least-connections
│       ├── caching-patterns.md           # Where, how, and what to cache
│       └── db-scaling.md                 # Sharding, replication, CAP tradeoffs
├── algo-thinking/           # Sharpen your problem-solving blade
│   ├── learn/
│   │   └── algorithm-strategy.md         # Patterns like DP, recursion, backtracking
│   └── read/
│       ├── binary-search.md              # Not just for sorted arrays
│       ├── sliding-window.md             # Efficient linear solutions
│       └── recursion-vs-iteration.md     # When stack frames beat loops


Scroll to Top