Christian Rackerseder | Blog

Make function contracts visible.

Ship a Node.js application with its runtime.

Semantic HTML makes structure and behavior explicit, supports accessibility and avoids rebuilding features the browser already provides.

JavaScript's using and await using declarations make deterministic cleanup and resource ownership part of lexical scope instead of a repeated try/finally convention.

Commented-out code, TODOs and explanatory prose often hide weak design or unowned work.

Runtime validation belongs where external data becomes application data.

Stubs control answers.

Choosing not to await a Promise does not remove responsibility for its failure.

Business logic should return application meaning, not localized text or translation keys.

When every layer logs the same failure, observability turns into noise.

Clever code may impress in a pull request.

Reading the current time looks harmless, but it hides infrastructure inside application logic.

A zero bug policy is not about perfect software.

Clean Architecture is not only about drawing onions or creating folders.

Integration and end-to-end tests become noisy when they depend on systems a team cannot make deterministic or act on.

DevOps should not be a ticket queue between product teams and production.

process.exit() forces Node.js to terminate and may abandon pending work.

Chrome DOM breakpoints let you pause on the code that changes, removes or mutates a DOM node.

Good Git commit messages are not bureaucracy.

Application performance is not something engineers can optimize in isolation.

Optimizing developer experience often has a bigger long-term impact than optimizing rendering benchmarks or bundle size.

JavaScript does not have pattern matching yet, but TypeScript developers can model states clearly and use ts-pattern for exhaustive pattern matching today.

Barrel exports in JavaScript reduce tree shaking effectiveness, hide dependencies and make code harder to maintain.

Direct access to window, document, navigator and globalThis couples your code to the runtime, makes side effects harder to isolate, and leads to brittle tests.

Logpoints let you inspect runtime behavior without changing your code, polluting commits, or pausing execution.

Testing Library is useful, but rendering components and testing them through the DOM is integration testing, not unit testing.

React Testing Library works best with semantic queries like role and label.

Git LFS solves a real problem for large binary files, but it also adds workflow and operational complexity that teams should adopt intentionally.

git bisect helps you find the commit that introduced a regression, but large squash merges remove the history that makes it truly effective.

Enums add runtime behavior, work against modern TypeScript workflows, and have simpler alternatives like string literal unions and const objects.

Code coverage shows what your tests execute.

Truthy and falsy checks in TypeScript hide intent and can introduce bugs.

Promises hide failure in an untyped rejection path.

Use Result in TypeScript for expected failures, Maybe for absence, and reserve exceptions for truly exceptional situations.

Why null still causes bugs in TypeScript - and how Maybe types make absence explicit.

Explicit dependencies improve clarity and testability.

Unit tests do not feel fragile because testing is hard.

Why I finally decided to start writing on echooff.dev and what I want this blog to be.