Why 0.1 + 0.2 !== 0.3 in JavaScript (and in almost every language)
How IEEE 754 floating-point numbers actually work, why this isn't a JavaScript-specific bug, and the safe ways to compare and store decimal numbers.
← Back to Tags
Posts tagged "javascript"
39posts
JavaScript's new Set methods: union, intersection, difference, and the rest
The native Set operations that shipped in modern engines — union, intersection, difference, symmetricDifference, isSubsetOf, isSupersetOf, isDisjointFrom — with before/after examples.
The most common forEach mistakes in TypeScript
forEach looks like the simplest array method there is, but in TypeScript it hides real traps: async callbacks TypeScript won't flag, narrowing lost inside closures, implicit-any indexing.
"Uncaught (in promise)": why your async error disappears from the console
The difference between a thrown exception and an unhandled promise rejection, why a surrounding try/catch sometimes doesn't help, and how to catch async errors correctly.
"Cannot read properties of undefined": JavaScript's most common error, explained
Why 'TypeError: Cannot read properties of undefined (reading ...)' happens, the three most common causes, and how optional chaining and nullish coalescing prevent it.
Iterator helpers: .map(), .filter(), and .take() directly on iterators
Why you used to need Array.from() before mapping/filtering an iterator, the new lazy iterator helper methods, and a practical example with an infinite generator.
TypeScript 7 and 7.1: what changes with the native compiler
TypeScript 7.0 rewrites the compiler in Go: 8-10x faster builds, new defaults, and breaking changes. What to expect from TypeScript 7.1 too, landing in November 2026.
Replacing Moment.js, date-fns, Luxon, and Day.js with Temporal
A practical migration cheatsheet: how to do formatting, parsing, arithmetic, diffing, comparison, and time zone conversion in Temporal, mapped directly to the Moment/date-fns/Luxon/dayjs calls you already know.
using and await using: explicit resource management in JavaScript
The problem of forgetting to close a resource on an early exception, how Symbol.dispose/Symbol.asyncDispose work, and a practical example compared to try/finally.
React 19: "Cannot update a component while rendering a different component"
What this warning means, the two patterns that trigger it (derived state, callback refs), and how to move the update out of the render phase.
React 19: "Too many re-renders", the infinite loop error explained
Why React throws 'Too many re-renders. React limits the number of renders...' and the two most common causes: setState in the render body and unstable effect dependencies.
"Maximum call stack size exceeded": when recursion goes out of control
What the call stack actually is, the two most common causes of a stack overflow in JavaScript, and how to convert deep recursion into an iterative version.
Temporal: the new JavaScript API that (finally) replaces Date
What's wrong with the legacy Date object, how Temporal fixes it, the core types (PlainDate, ZonedDateTime, Duration...), and where support stands in 2026.
"Cannot access before initialization": the Temporal Dead Zone explained
Why let and const throw ReferenceError instead of returning undefined like var, what the Temporal Dead Zone actually is, and the patterns that trigger it by accident.
"Objects are not valid as a React child": what it means and the three usual causes
Why JSX won't render an object directly, the three real-world cases that trigger it (Date, error objects, Map/Set), and how to fix each one.
React Server Components: what they are and how they change the way you write components
Server Components vs Client Components, the 'use client' and 'use server' directives, what runs where, and how they pair with Suspense and use().
React 19: `use` vs `useContext`, what changes and when to pick each
React 19's new use() API overlaps with useContext but breaks the Rules of Hooks on purpose. Here's how they differ, with examples for context and promises.
React Compiler: the stale UI bug hiding between two components that both look correct
A React Compiler bug where one component bails out of memoization while its sibling silently gets memoized, freezing UI fed by a stable object reference. Root cause and fix.
What is (0, foo)() in webpack/Babel-compiled code
Why Babel and webpack-compiled code wraps some function calls in (0, ...)(), and what the comma operator has to do with the value of this.
TypeScript's satisfies operator: what it's actually for
TypeScript's satisfies operator explained with practical examples: why as and explicit annotations lose inference, and how satisfies solves the problem without trade-offs.
!function(){}(): what it is and why an IIFE is written that way
What an IIFE is, why it sometimes starts with !, + or void before function, and where it still shows up in JavaScript code today.
Node.js's built-in test runner: is it worth ditching Jest?
A practical guide to node:test, Node.js's built-in test runner: zero-dependency setup, basic syntax, mocking, coverage, and what's still missing compared to Jest.
React Compiler: what changes for anyone writing components today
What the React Compiler actually does, when useMemo and useCallback become unnecessary, and why the Rules of React matter more than before.
Web Workers in JavaScript: how they work, and when (and how) to use them
What main thread blocking is, how to create a Web Worker to move heavy computation off the UI, and when you don't actually need one.
Advanced CSP: nonces, strict-dynamic and Trusted Types
Why unsafe-inline isn't enough, how CSP nonces and hashes work for a static site, what strict-dynamic is, and what Trusted Types is for.
AbortController: how to cancel a fetch in JavaScript
How to use AbortController and AbortSignal to cancel fetch requests and other async operations, avoiding race conditions and wasted network calls.
WebAuthn and Passkeys: how passwordless authentication really works
How the WebAuthn protocol behind passkeys works — public keys, attestation, a practical example — and why they're not just a more convenient alternative to passwords.
Node.js - January 2026 Security Releases
Security updates for Node.js 25.x, 24.x, 22.x and 20.x: 3 high-severity vulnerabilities, 4 medium and 1 low. Here is what they fix and how to update.
javascript:void(0), what is it?
What javascript:void(0) is and what it's for, with a few simple examples
Proxies in JavaScript
How JavaScript Proxies work, some code examples, and how to use them for reactivity in JS
Decorators in JavaScript
A simple guide to decorators in JavaScript with practical examples
Astro trailing slashes and canonical tags
How to correctly set slashes in URLs and canonical HTML tags for Astro-based applications
React: useActionState and useFormStatus
Let's look at a few examples of how React 19's new useActionState and useFormStatus hooks work
How Error Boundaries work in React, with examples
How Error Boundaries work in React: components that catch errors from their children to improve your app's stability and reliability.
Debounce and Throttle in JavaScript: A Simple Guide
Difference and examples between debounce and throttle for events in JavaScript
React: event handlers and hooks
How to correctly handle event handlers in React, including events on window like resize and scroll, avoiding the most common mistakes.
CSP: how Content Security Policy works
Content Security Policy, or CSP, is a set of rules that tell the browser how to behave when loading the content of our HTML page.
JavaScript: stopPropagation and preventDefault
How stopPropagation and preventDefault work in JavaScript to control event propagation and the browser's default behavior.
TypeScript 5.4: the new NoInfer utility
The new NoInfer<T> utility introduced in TypeScript 5.4 to control generic type inference, with practical examples.