All bites
The whole library, newest first. Filter by what you are here for, or pick a topic if you already know.
4247 bites
Page 185
Five Whys: From Symptom to Root Cause
The Five Whys is a root cause analysis technique that traces a problem to its origin by asking 'Why?' repeatedly. It's used in post-mortems to find the underlying process failure, not just the surface-level symptom. The footgun is stopping at human error.
Hypothesis-Driven Development: Stop Guessing, Start Learning
Hypothesis-Driven Development treats new features as experiments, not foregone conclusions. It's used to de-risk major changes by first testing the core assumption with a minimal product. The biggest footgun is writing vague, untestable hypotheses.
Throughput: Measuring What Gets Done
Throughput measures how many work items a team *finishes* in a time period, not how busy they are. It's used for forecasting future work and spotting bottlenecks. The footgun: never compare throughput between different teams, as item sizes and context vary.
Classes of Service: Prioritize Work Beyond 'First In, First Out'
Classes of Service are policies that prioritize work by its business impact, not just arrival time. When a bug, a deadline, and normal work compete, CoS tells you which to pull first.
Flow Efficiency: Are You Working or Waiting?
Flow efficiency measures the ratio of active work time to total lead time, revealing how much time tasks spend just waiting. Use it to diagnose why features take so long to ship. The biggest footgun is optimizing work speed when most delays hide in queues.
Right-Shifting Forecasts: Why Your Deadlines Keep Moving
A forecast is like a GPS ETA in traffic; new tasks are like accidents ahead, pushing your arrival time further out. This happens when initial estimates are treated as fixed deadlines, ignoring new scope. The footgun is anchoring on the first date given.
Nexus Framework: Scaling Scrum Without Breaking It
Nexus is a lightweight wrapper for 3-9 Scrum teams working on one product. It adds a coordinating Nexus Integration Team and shared events to manage dependencies and deliver a single, integrated increment each sprint.
Nexus Integration Team: Air Traffic Control for Scrum
The Nexus Integration Team is like air traffic control for multiple Scrum teams, guiding them to a single, integrated product. It's used in the Nexus framework to coordinate 3-9 teams on one product, resolving cross-team dependencies and integration failures.
Communities of Practice: Scaling Knowledge Across Teams
A Community of Practice is a cross-team guild for a specific skill, like 'frontend' or 'testing'. It's how large orgs prevent knowledge silos, standardize tooling, and mentor juniors. The footgun: they fail without dedicated time and a clear charter.
Agile Center of Excellence: Internal Consultants, Not Process Police
Think of an Agile CoE as internal consultants, not process police. They enable teams by providing coaching, tools, and shared standards. They're useful for scaling Agile consistently, but fail when they become a bureaucratic bottleneck instead of an…
TypeScript Type Annotations: Defining Your Data's Shape
Type annotations are contracts for your data, telling TypeScript what to expect from variables and functions. You'll use them for primitives like string or number, and for arrays like string[].
TypeScript's Basic Types: The Building Blocks
TypeScript builds on JavaScript's primitives (string, number, boolean) by letting you explicitly declare a variable's type. This is the foundation for catching errors early. The main footgun is confusing tuples [string, number] with flexible arrays.
TypeScript Type Inference: How It Knows Without Being Told
TypeScript's type inference deduces types so you don't have to annotate everything. It infers types from variable initializations and function returns. The main footgun is its 'best common type' for arrays, which can create an overly specific union type.
Union Types: When a Value Can Be One of Several Things
A Union Type is an 'OR' for your types, letting a value be one of several options, like string | number. Use it for flexible function arguments or varied API responses. The footgun: you can only use properties common to all types until you narrow.
TypeScript Interfaces: Naming the Shape of Your Data
An interface is a contract for an object's shape, caring what properties it has, not its class. Use it to define function parameters or API responses. The footgun: TypeScript allows objects with extra properties, checking only for the required ones.
TypeScript Function Types: Expressions vs. Signatures
TypeScript describes function shapes with type expressions or call signatures. Use a simple expression like (s: string) => void for callbacks. For functions with properties, use a call signature. The footgun: parameter names are required in type expressions.
tsconfig.json: The Rulebook for Your TypeScript Project
The tsconfig.json file is the rulebook for the TypeScript compiler, defining which files to process and what rules to enforce. It's essential for setting strictness, module resolution, and output targets.
TypeScript Enums: Named Constants for Clarity
TypeScript enums give friendly names to a fixed set of values, like Status.Success instead of a magic number. Use them for API response codes or state machines. The footgun: default numeric enums are just numbers at runtime, making them hard to debug.
Literal Types: Be More Specific Than `string`
Literal types specify the *exact* value a variable must hold, not just its general type like string. They're great for creating fixed option sets with unions, like type Status = "pending" | "complete".
The `window` Object: Your Browser's Global Scope
Think of the window object as the global stage for your JavaScript. It represents the browser tab and holds all global variables and APIs like fetch and setTimeout. You use it constantly, often implicitly.