Tag: #fundamentals

한국어English日本語中文

← All posts

• Learning How to Learn — Telling Fundamentals From Fashion, and Choosing One Thing to Go Deep On

  A learning strategy usually arrives as a list of things to learn, when what is actually needed is a criterion for what not to learn. This piece covers the single question that separates fundamentals from fashion, the rul

  2026-08-15 · 7 min read #career#skills#learning#fundamentals#deliberate-practice

• Reading Git commands through its internals — reset and rebase seen as objects, refs and the index

  Memorizing Git commands means searching for them again every time, but knowing the data model lets you deduce what a command does. This post opens up the four object types (blob, tree, commit, tag), content addressing in

  2026-07-26 · 12 min read #git#internals#git-objects#fundamentals#version-control

• Debugging Like a Scientist: Hypothesis-Driven Debugging

  Instead of staring at code and changing things at random, debug like a scientist: form a hypothesis, make a prediction, and test it. Binary-search the problem space, build a minimal reproducible example, hunt the culprit

  2026-07-03 · 14 min read #debugging#engineering#productivity#fundamentals

• Concurrency vs Parallelism — Dealing With vs Doing Many Things

  Rob Pike's famous distinction — concurrency is about "dealing with" many things, parallelism is about "doing" many things at once. This post walks through threads and event loops, race conditions and data races, mutexes

  2026-07-03 · 12 min read #concurrency#systems#fundamentals

• What Happens When You Type a URL and Hit Enter: A Full-Stack Tour from Browser to Pixel

  How much really happens in the one second between typing a URL and seeing a page? URL parsing, DNS resolution with recursive queries and caches, the TCP three-way handshake, the TLS handshake, the HTTP request and respon

  2026-07-02 · 11 min read #networking#web#fundamentals

• How to Read Code You Didn't Write

  Developers spend far more time reading code than writing it, yet nobody teaches code reading. Find the entry point, follow the data instead of every line, treat tests and types as documentation, draw call graphs with gre

  2026-07-01 · 11 min read #code-reading#engineering#onboarding#fundamentals

• Naming Things: The Hardest Easy Skill in Code

  The joke that "there are only two hard things in computer science: cache invalidation and naming things" is only half a joke. Why a good name reveals intent rather than implementation, how name length scales with scope,

  2026-06-30 · 8 min read #clean-code#engineering#fundamentals

• Regex From Zero to Confident: Character Classes, Quantifiers, Anchors, Groups, Lookarounds, and ReDoS

  If regular expressions have always looked like line noise, let this post fix that. We build up the pieces one at a time — character classes, quantifiers, anchors, groups, alternation, lookarounds — then cover greedy vers

  2026-06-29 · 10 min read #regex#programming#fundamentals

• The Birthday Paradox and Hash Collisions — Why 23 People Means a 50% Match

  Just 23 people in a room, and the odds that two share a birthday cross 50%. At the root of this counterintuitive result is a √N approximation, and the same math runs through UUID and hash collision probability, why 128 b

  2026-06-27 · 11 min read #math#hashing#fundamentals

• Stack vs Heap: How Memory Really Works

  The stack and the heap are not just "two regions of memory." One is a fast, fixed, LIFO world of frames; the other is a dynamic space ruled by malloc and garbage collectors. This post digs from the ground up into pointer

  2026-06-24 · 16 min read #systems#memory#fundamentals

• Big-O in Practice: Complexity Without the Math Anxiety

  What O() actually means, the common complexity classes with real-world examples, when constants win because n is small or the cache matters, the O(n squared) that hides in nested loops and N+1 queries, space complexity,

  2026-06-22 · 11 min read #algorithms#performance#fundamentals

• Floating Point: Why 0.1 + 0.2 ≠ 0.3

  In almost every language, 0.1 + 0.2 produces something that is not 0.3. It is not a bug; it is the designed behavior of IEEE 754. This post unpacks the truth about floating point from the ground up: how binary floating p

  2026-06-20 · 12 min read #floating-point#ieee754#fundamentals#numerics

• Self-Directed Learning Is What Grows Me — Turning Career Hunger into Fuel

  The anxiety you feel before LeetCode and job postings is actually a good sign. In the end, what grew me was not study someone assigned but study I sought out myself. Here is how to turn career hunger into fuel, and how n

  2026-06-19 · 37 min read #culture#self-directed-learning#career-growth#fundamentals#motivation

• Following the Essence — A Life Built on What Does Not Change

  A reflection on spending your time on fundamentals and essence instead of chasing trends. It covers how to separate what changes from what stays the same, how to reason from first principles, and how to make choices your

  2026-06-19 · 28 min read #culture#first-principles#essence#long-term-thinking#self-improvement

• Reading Financial Statements — Income, Balance Sheet, and Cash Flow

  A beginner-friendly walkthrough of the three core financial statements, the starting point for understanding a company. It covers revenue and profit on the income statement, debt and equity on the balance sheet, operatin

  2026-06-18 · 18 min read #finance#financial-statements#accounting#investing#fundamentals

• Unicode and UTF-8: The Text Encoding Minefield

  Bytes, code points, and grapheme clusters are three different layers. Why the length of a single emoji lies, what separates UTF-8 from UTF-16 and UTF-32, NFC/NFD normalization and the é problem, ZWJ-joined emoji, surroga

  2026-06-16 · 11 min read #unicode#text#fundamentals

• Timestamps and Time Zones, Done Right

  Store UTC, display local. The epoch vs ISO 8601, the crucial difference between an offset and a time zone (the IANA tz database), the gaps and overlaps DST creates, leap seconds, why you must never trust the client clock

  2026-06-14 · 12 min read #datetime#timezone#fundamentals

• How Git Actually Stores Your Data

  Most of us use Git every day without knowing what its insides look like. A ground-up tour of the object model (blob, tree, commit, tag), content addressing by SHA hash, the commit DAG, the fact that branches are just poi

  2026-06-13 · 14 min read #git#version-control#fundamentals

• Falsehoods Programmers Believe About Time

  A day has 24 hours, a minute has 60 seconds, the clock only moves forward, a time zone is a fixed offset. Every one of these propositions that programmers take for granted about time is false. We walk the famous "falseho

  2026-06-12 · 9 min read #datetime#timezone#fundamentals