X vs Y, decided honestly

JSON is the safer default for anything machines write and parse — APIs, saved app state, data interchange between services. YAML is worth its extra risk only for files humans hand-edit often, like CI configs, provided everyone remembers to quote values that look like booleans or numbers.

POST creates a new resource and lets the server assign its URL, so calling it twice can create two resources. PUT replaces a resource at a URL the client already knows, and calling it twice with the same body should leave the server in the same state — that's what 'idempotent' buys you.

SQL wins when your data has clear relationships and you need transactional guarantees across them — the default for most business applications. NoSQL wins when the schema changes shape often, when a query should hit one self-contained document instead of joining several tables, or when horizontal write scale matters more than strict consistency.

REST is simpler to build, cache and reason about, and it's the safer default for a small API with a handful of clients. GraphQL earns its extra complexity when multiple clients need different shapes of the same data and round trips are expensive — mobile apps on flaky networks, or one backend serving many different frontends.

Auto-increment integers are smaller, faster to index, and simplest for a single database. UUIDs cost more storage and can fragment indexes, but they let you generate IDs offline, merge data from multiple sources without collisions, and avoid leaking your row count to anyone reading the URL.

WebP produces meaningfully smaller files than PNG at equivalent quality, in both lossy and lossless modes, and every browser still in meaningful use supports it — so for web images it's the better default. PNG stays the safer choice for images that travel outside the browser: design files, print pipelines, or any app you don't control that might not read WebP.

Spaces render identically everywhere, which is why most modern style guides and formatters (Prettier, Black, PEP 8) default to them — consistency across editors and diffs matters more than the minor storage or accessibility wins tabs offer. If your language's own tooling mandates tabs (Go's gofmt, Makefiles), match that instead of relitigating the debate.

Default to const; reach for let only when you know the binding will be reassigned — a loop counter, an accumulator, a value that genuinely changes. This isn't just style — const catches an accidental reassignment at parse time, and a codebase that's mostly const makes the few lets stand out as the places state actually changes.

localStorage is the right place for client-only data the server never needs to see — UI preferences, cached API responses, draft form state. Cookies remain the better fit for anything involving authentication, because they're the only mechanism sent automatically to the server and can be marked HttpOnly, which JavaScript-based storage can never do.

There's no real argument for plain HTTP on a public site anymore — free certificates, automatic renewal, and browser-side pressure (mixed-content warnings, disabled APIs) closed the gap that used to justify skipping it. HTTPS is the default; the only real question is whether a specific internal or local-dev context can reasonably skip it.

INNER JOIN keeps only rows that match on both sides — use it when a missing related row makes the result meaningless anyway. LEFT JOIN keeps every row from the left table regardless of a match, filling unmatched columns with NULL — use it whenever 'no related row' is itself a valid, meaningful case, like customers with zero orders.

Modern npm (v7+) has closed most of the gap that made Yarn's early speed and determinism advantages compelling, so for most projects sticking with whichever one is already in your lockfile beats migrating. Yarn (via Berry/PnP) still pulls ahead for very large monorepos where install speed and strict dependency resolution matter enough to justify the tooling change.

Flexbox lays out items along one axis — a row of buttons, a nav bar, centering something — letting content size drive the layout. Grid lays out two axes at once — a page skeleton, a card gallery — for when you want to define rows and columns first and place content into them.

JSON is lighter, maps directly onto objects and arrays in most programming languages, and is the default for new APIs. XML still earns its place where you need document-oriented features JSON doesn't have — namespaces, mixed content, mature schema tooling (XSD) — which is why it persists in enterprise, SOAP and document formats long after losing the API popularity contest.