Lesson 1: Architecture Refresher
Rebuild the computer from electrons to main(). Transistors, gates, CPU pipeline, cache, virtual memory, interrupts, and memory ordering.
Sirin's Note
Personal notes on Computer Science, Machine Learning, and related topics.
Live Last read · last published · next check
Latest posts
Lesson 2: Processes & Kernel Interface
Implement a working shell from scratch. fork, exec, file descriptors, pipes, signals, process groups, and job control.
Lesson 3: PTY & Terminal Driver
Master the kernel construct at the heart of every terminal emulator. PTY pairs, termios, line discipline, job control, and window size.
Lesson 4: Memory Management Deep Dive
Go from 'I know what malloc is' to designing memory allocators. Page tables, malloc internals, slab allocation, NUMA, and the vLLM KV-cache bridge.
Lesson 5: Threads & Lock-Free Concurrency
Build the communication primitives Ghostty uses. pthreads, atomics, memory ordering, SPSC queues, thread pools, and false sharing.
Lesson 6: Terminal Protocol
VT100 state machine, CSI/OSC/DCS parsing, SGR attributes, kitty keyboard protocol, and building a VT parser from scratch.
Lesson 7: GPU & Rendering Pipeline
GPU architecture, shaders, texture atlases, FreeType font rasterization, HarfBuzz text shaping, and rendering Hello, 世界! with textured quads.
Lesson 8: Integration & Ghostty Contribution
Wire everything together into toyterm — a working terminal emulator. Then read Ghostty source, build it, and ship a PR.
From Logic Gates to Production Terminal Emulators
Rebuild the computer from electrons to a GPU-accelerated terminal emulator — then contribute to Ghostty with genuine understanding.
Lesson 1: The Algorithm Is Just a System
Every platform runs the same control flow. Learn to read the source code.
Lesson 2: Conversations That Convert
Leads don't come from CTAs. They come from conversations that made someone think 'this person knows something I need.'
Lesson 3: Writing That People Actually Read
Good code is clear, maintainable, and does one thing well. Good writing is the same thing. Stop writing like a documentation page.
Lesson 4: Distribution Is Deployment
Writing is the product. Distribution is the CI/CD pipeline. You don't deploy code once and expect it to run forever.
Lesson 5: Content Ideas and the 30-Day Playbook
How to never run out of things to write about, and the actual plan for your first 30 days.
Lesson 6: Analytics for People Who Hate Marketing Math
How to know if any of this is actually working — without becoming a spreadsheet person.
Lesson 7: Building in Public
The strategy that turns your actual engineering work into marketing — without feeling like a LinkedIn influencer.
Organic Marketing & Distribution
How platforms actually work, how to write things people read, and how to get your ideas in front of humans who care — all explained by someone who thinks like an engineer.
Emotional Addiction - Joe Dispenza on Rewiring Your Brain
The Emotional Addiction Nobody Talks About Trauma Is in Your Body, Not Your Head 50% of Your Past Isn't Even True The Change Mechanics: How the Body Fights Back Heart-Brain Coherence: The Biological Reset Button Brain Waves: From Beta Hell to Gamma Transcendence The Quantum Model (หรือ "ทำไมแค่คิดก็
Learning How to Learn - Barbara Oakley on the Science of Studying
The Two Modes: Focused and Diffuse How Neurons Actually Learn (the Space Alien Metaphor) Retrieval Practice: The King of Study Techniques Spaced Repetition: Let the Mortar Dry Sleep: Your Brain's Consolidation Engine Exercise = Brain Fertilizer The Pomodoro Technique (Real Version, Not the Academic
Lesson 1: Go Interfaces: Implicit Satisfaction
The one Go feature that changes how you design software
0001: Learning Path Foundation
Context Insight Consequences 0001: Learning Path Foundation Date: 2026-06-14 Status: Accepted Context Establishing the optimal learning sequence for a Go beginner+ aiming to contribute to cloud-native open source projects. The learner knows Go syntax basics but needs depth in idiomatic patterns. Tar
0002: Error Handling Builds on Interfaces
Context Insight Consequences 0002: Error Handling Builds on Interfaces Date: 2026-06-14 Status: Accepted Context The learner has completed Lesson 0001 (Go interfaces — implicit satisfaction). The next step is error handling, which is a direct application of interfaces: Go's error type is just a sing
Lesson 2: Go Error Handling: The error Interface
Errors aren't exceptions. They're values that implement an interface.
Lesson 3: Struct Tags, JSON & Protobuf
How Go drives serialization with struct field metadata
0003: Struct Tags Are Reflection-Driven Metadata
Context Insight Consequences 0003: Struct Tags Are Reflection-Driven Metadata Date: 2026-06-14 Status: Accepted Context Learner has completed interfaces (0001) and error handling (0002). The next skill needed for cloud-native contribution is understanding how Go drives serialization, validation, and
Lesson 4: Go Testing: Table-Driven Tests & Interface Mocks
No frameworks. Just the testing package, tables, and interfaces.
0004: Testing Depends on Interfaces
Context Insight Consequences 0004: Testing Depends on Interfaces Date: 2026-06-14 Status: Accepted Context Learner has completed interfaces (0001), error handling (0002), and struct tags (0003). The next essential skill for cloud-native contribution is writing tests — table-driven tests, subtests, a
0005: Concurrency Is Go's Superpower
Context Insight Consequences 0005: Concurrency Is Go's Superpower Date: 2026-06-14 Status: Accepted Context Learner now has interfaces, error handling, struct tags/JSON, and testing. The next frontier is concurrency — the feature that makes Go the language of choice for cloud-native infrastructure.
Lesson 5: Goroutines & Channels
Share memory by communicating, not communicate by sharing memory
0006: Sometimes You Need Locks — sync, atomic & the Race Detector
Insight Consequences 0006: Sometimes You Need Locks — sync, atomic the Race Detector Date: 2026-06-14 Status: Accepted Insight Channels are the Go way, but they're not always the right tool. When you have a simple shared counter, a sync.Mutex is clearer than a channel. When you need to wait for N go