A continuing bilingual series building a connected conceptual network across AI, philosophy, psychology, language, learning, music and life.
- Adaptability: Why Changing the Method Does Not Mean Abandoning the Goal
- Affordance: How Environments Offer Possibilities for Action
- Aliasing: How Can Two Names Refer to the Same Thing?
- Atomicity: Why Must a Group of Operations Succeed or Fail Together?
- Backoff: Why Shouldn't We Retry Immediately After Failure?
- Backpressure: Why Must Downstream Congestion Reach Upstream?
- Backward Compatibility: Why Can Old Things Still Work After a System Changes?
- Batching: Why Can Waiting to Do Things Together Be Faster?
- Bottlenecks: Why Does the Slowest Stage Limit the Whole System?
- Boundary Objects: How Can People Cooperate Without Complete Agreement?
- Buffering: How Temporary Storage Helps Fast and Slow Systems Work Together
- Calibration Makes Confidence Match Reality
- Checkpointing: Why Is Saving Intermediate State Not the Same as a Backup?
- Checksums: How Can a Short Value Reveal That Content Has Changed?
- Circuit Breakers: Why Can Temporarily Rejecting Requests Protect a Service?
- Closure: Why Does an Operation Keep Results in the Same Domain?
- Cognitive Offloading: Moving Part of Memory Outside the Mind
- Commutativity: When Does Order Change the Result?
- Composability: Why Can Small Parts Repeatedly Build Larger Structures?
- Composability: How Small Units Form Larger Systems
- Compression: How Can Fewer Symbols Preserve Information?
- Consistency: Why Must Multiple Copies Follow Shared Rules?
- Context: Why the Same Sentence Can Change Meaning
- Controllability: Why Does Seeing a State Not Mean We Can Change It?
- Convention: How Can a Human-Made Rule Create Real Constraints?
- Counterexample: Why Can One Case Refute a Universal Claim?
- Counterfactuals: Why ‘What If’ Is More Than Fantasy
- Coupling: Why Do Two Parts Change Together?
- Debouncing: Why Wait for Input to Settle Before Acting?
- Defaults: How Does a System Continue When No Choice Is Made?
- Degeneracy: Why Can Different Structures Perform Similar Functions?
- Delegation: Why Does Transferring Authority Not Erase Responsibility?
- Emergence: Why Does a Whole Have Properties Its Parts Lack?
- Encapsulation: Why Hiding Internals Reduces Cascading Errors
- Equivalence: How Can Different Things Still Count as the Same?
- Explainability: Why Accurate Prediction Is Not Yet an Explanation
- Externalities: Why Do Others Bear the Effects of Our Choices?
- Feedback Loops: How Results Change What Happens Next
- Freshness: Why Can Information That Was Correct Become Unreliable?
- Friction: Why Can One Extra Step Improve a Decision?
- Grace Period: Why Leave Time Before a Rule Takes Full Effect?
- Graceful Degradation: Why Is Partial Use Better Than Total Failure?
- Granularity: Why Does the Same Problem Change with Scale?
- Hysteresis: Why Does the State Not Return as Soon as Conditions Do?
- Idempotence: Why Should Repetition Stop Changing the Result?
- Identifiability: Why Can the Same Result Have Different Explanations?
- Interfaces: Why Does Connection Begin with Constraints?
- Interoperability: Why Is Exchanging Data Not Yet Working Together?
- Invariants: What Stays the Same Through Change?
- Isolation: Why Must Shared Systems Limit Mutual Interference?
- Latency: Why Does a Time Gap Change the Relationship?
- Leases: Why Must Authority Be Renewed to Remain Valid?
- Least Privilege: Why Should Access Be Limited to What a Task Needs?
- Liveness: Why Does the Absence of Failure Not Guarantee Progress?
- Local Optima: Why Can Every Better Step Still Miss the Best?
- Metacognition: Knowing How Your Own Thinking Is Going
- Models: Why Does Simplification Not Equal Distortion?
- Monotonicity: Why Shouldn't New Information Undo an Old Conclusion?
- Mutual Exclusion: Why Should Shared State Have Only One Editor at a Time?
- Namespaces: Why Do Identical Names Not Always Conflict?
- Non-monotonic Reasoning: Why Can More Information Retract an Earlier Conclusion?
- Observability: Why Does Seeing Outputs Not Yet Mean Understanding a System?
- Orthogonality: Why Should Good Dimensions Not Quietly Replace One Another?
- Path Dependence: Why Does the Past Constrain Present Choices?
- Provenance: Why Does Information Need a Traceable Origin?
- Proxy Metrics: Why Is What We Measure Not Always the Goal?
- Quorum: Why Can't a Few Attendees Decide for the Whole Group?
- Race Conditions: When Two Correct Actions Produce a Wrong Result
- Rate Limiting: Why Does Permission Not Mean Unlimited Speed?
- Reachability: Why Does an Existing Outcome Not Mean We Can Get There?
- Recursion: How Can One Rule Enter Itself Layer by Layer?
- Why Is Redundancy Not the Same as Waste?
- Referential Transparency: Why Can an Expression Be Replaced Without Changing the Result?
- Regularisation: Why Can a Less Exact Fit Be More Reliable?
- Representation: How Can One Form Stand In for Something Else?
- Reversibility: Preserving the Possibility of Return
- Robustness: Why Does Stability Not Mean Absence of Change?
- Robustness Lets a Conclusion Survive Small Changes
- Salience: Why Is What Stands Out Not Necessarily Important?
- Scaffolding: Why Must Good Support Eventually Withdraw?
- Sensitivity: Why Can Small Changes Become Amplified?
- Slack: Why Isn’t Unused Capacity Necessarily Waste?
- State: Why Does the Present Not Need to Preserve the Entire Past?
- Substitutability: Why Can a System Keep Working After a Part Is Replaced?
- Synchronisation: How Do Separate Processes Stay Aligned in Time?
- Thresholds: Why Does Continuous Change Become a Discrete Decision?
- Timeout: Why Must Waiting Have a Boundary?
- Why Boundaries Matter