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?
- Ambiguity: Why Can One Sentence Support More Than One Interpretation?
- Atomicity: Why Must a Group of Operations Succeed or Fail Together?
- Audit Trail: Why Must We Be Able to Reconstruct Who Did What?
- Auditability: Why Must We Be Able to Reconstruct What Happened?
- 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?
- Bounded Rationality: Why Is the Best Choice Often Out of Reach?
- Buffering: How Temporary Storage Helps Fast and Slow Systems Work Together
- Calibration Makes Confidence Match Reality
- Cancellability: Why Should a Started Process Still Be Stoppable?
- Canonical Form: Why Choose One Representative for Equivalent Expressions?
- 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
- Cohesion: Why Should Work That Belongs Together Stay Together?
- Commitment Devices: Why Can Limiting Future Choice Increase Freedom?
- Common-Cause Failure: Why Can Two Backups Fail Together?
- Commutativity: When Does Order Change the Result?
- Complementarity: Why Can One Capability Make Another More Valuable?
- Composability: Why Can Small Parts Repeatedly Build Larger Structures?
- Composability: How Small Units Form Larger Systems
- Compression: How Can Fewer Symbols Preserve Information?
- Confluence: Why Can Different Paths Still Reach the Same Result?
- Consistency: Why Must Multiple Copies Follow Shared Rules?
- Contestability: Why Must a Decision Remain Open to Challenge?
- 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?
- Coordination Cost: Why Doesn’t Adding More Participants Always Speed Up Collaboration?
- 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?
- Decay: Why Does an Effect Gradually Weaken over Time?
- 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?
- Dependency: Why Does Having a Capability Not Mean It Is Always Available?
- Deprecation: Why Does No Longer Recommended Not Mean Immediate Removal?
- Discoverability: Why Can an Existing Function Feel Absent?
- Duality: Why Can One Problem Have Two Translatable Forms?
- 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?
- Eventual Consistency: Why Can Temporary Disagreement Still Be Correct?
- Explainability: Why Accurate Prediction Is Not Yet an Explanation
- Externalities: Why Do Others Bear the Effects of Our Choices?
- Fallback: Why Should There Be a Next Step When the Preferred Option Fails?
- Feedback Loops: How Results Change What Happens Next
- Fidelity: Why Does Faithfulness Not Mean Being Identical?
- 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?
- Immutability: Why Can an Edit Mean Creating a New Version?
- 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?
- Lag: Why Has the Cause Changed Before the Result Catches Up?
- Latency: Why Does a Time Gap Change the Relationship?
- Latent Variables: How Can Unseen Structure Enter a Model?
- Leaky Abstraction: Why Does a Simple Interface Still Expose What Lies Beneath?
- Leases: Why Must Authority Be Renewed to Remain Valid?
- Least Privilege: Why Should Access Be Limited to What a Task Needs?
- Legibility: Why Can Clarity Still Leave Things Out?
- Legibility: Why Must a Correct State Also Be Easy to Read?
- Leverage Points: Why Does Changing the Right Place Matter More Than Pushing Harder?
- Liveness: Why Does the Absence of Failure Not Guarantee Progress?
- Local Optima: Why Can Every Better Step Still Miss the Best?
- Locality: Why Is Nearby Information Often Used Again?
- Maintainability: Why Working Today Does Not Mean Easy to Fix Tomorrow
- Mediation: How Does a Cause Reach an Outcome?
- 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?
- Normalisation: Why Should One Fact Not Be Stored Everywhere?
- Observability: Why Does Seeing Outputs Not Yet Mean Understanding a System?
- Opportunity Cost: What Does ‘Free’ Leave Out?
- Option Value: Why Can Keeping a Choice Open Be Valuable?
- Orthogonality: Why Should Good Dimensions Not Quietly Replace One Another?
- Path Dependence: Why Does the Past Constrain Present Choices?
- Portability: Why Can Something Keep Working in a New Environment?
- 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?
- Recoverability: Why Must a System Return to a Usable State After Failure?
- 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: Why Should a Decision Leave a Way Back?
- Reversibility: Preserving the Possibility of Return
- Robustness: Why Does Stability Not Mean Absence of Change?
- Robustness Lets a Conclusion Survive Small Changes
- Safety Margin: Why Is Just Enough Not Enough?
- Salience: Why Is What Stands Out Not Necessarily Important?
- Sampling: When Can a Small Part Tell Us About the Whole?
- Saturation: Why Does More Input Stop Producing More Output?
- Scaffolding: Why Must Good Support Eventually Withdraw?
- Scalability: Why Doesn’t Adding Resources Always Increase Capacity?
- Sensitivity: Why Can Small Changes Become Amplified?
- Signal-to-Noise Ratio: Why Can More Information Make Judgement Harder?
- Single Point of Failure: How Can One Small Part Stop a Whole System?
- Slack: Why Isn’t Unused Capacity Necessarily Waste?
- Starvation: Why Can Work Wait Forever While Resources Keep Moving?
- 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?
- Tolerance: Why Can Allowing Variation Make a Fit More Reliable?
- Trade-offs: Why Does Gaining One Thing Often Mean Giving Up Another?
- Transaction Costs: Why Is the Price Not the Whole Cost of Exchange?
- Verifiability: Why Is ‘Plausible’ Not Enough?
- Why Boundaries Matter