"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.
Blog
News and articles on Web Development, Node.js, Fastify, React and cybersecurity.
What is shadcn/ui and how to install and use it (with examples)
shadcn/ui isn't a component library like the others: you don't install it, you copy it. How the CLI works, what Radix UI and Tailwind do under the hood, and when it's actually worth using.
"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.
Joining the Lora Italia LoRa mesh network: a first-node guide
A practical guide to joining the Lora Italia mesh network in Italy: recommended hardware, basic Meshtastic node setup, and how to show up on the map.
Meshtastic vs Meshcore: which firmware to choose for your LoRa mesh network
Differences between Meshtastic and Meshcore, the two most-used firmwares for building mesh networks over LoRa radio: routing, community, hardware, and when to pick each.
React Router: why route.lazy blocks the URL/Outlet swap
route.lazy in React Router blocks the URL/Outlet swap until the chunk is ready: why it happens, and how Component: lazy(...) gets an immediate swap.
LoRa: what it is and how long-range low-power radio works
What LoRa radio technology is, how its modulation works, how it differs from LoRaWAN, and its main use cases, from IoT to emergency mesh networks.
Portainer: a web UI for Docker (and how it compares to the alternatives)
What Portainer is, how to install it in minutes, and how it stacks up against Docker Desktop, Rancher, Lens and Dockge.
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.
Fastify vs Express in 2026: which one for a new project
A practical comparison between Fastify and Express in 2026: performance, plugin architecture, schema-based validation, ecosystem maturity, and when to pick one over the other.
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.
Core Web Vitals: LCP, CLS and INP explained with a real case
What LCP, CLS and INP actually measure, why your local Lighthouse often lies, and the real fixes applied on this blog to get past it.
Building a REST API with Fastify and TypeScript
A practical guide to Fastify with TypeScript: routing, schema validation, and plugin architecture, to build a fast, typed REST API from scratch.
UUID, ULID, NanoID and CUID2: which ID should you use in 2026?
A complete guide with JavaScript and TypeScript examples on UUID v4/v7, ULID, NanoID and CUID2.
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.
WPDockerize: WordPress with Docker, made simple
wpdockerize is an npm package for creating a Docker stack for WordPress
Google Chrome won't connect to the local network on macOS
Having trouble getting Google Chrome to connect to local servers, e.g. .local addresses? Here is how to fix it
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
Fit2Social web app
A small web app for resizing images for social networks (Facebook, Instagram, LinkedIn, TikTok)
Astro trailing slashes and canonical tags
How to correctly set slashes in URLs and canonical HTML tags for Astro-based applications
List of Dashicons names from the WordPress docs
Snippet to extract the list of Dashicons names from the WordPress documentation page
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.
Git log with graph and decorations
A mnemonic trick to remember the parameters of git log --all --decorate --oneline --graph: think of the phrase A Dog.
Guide to useReducer in React
A practical guide to React's useReducer hook: how it works, when to prefer it over useState, and a complete example for managing complex state.
using the HTTP HEAD method
How to request information about an HTTP resource without downloading its body
React: how useContext works (with examples)
How the useContext hook works in React to share data between components without props drilling, with a practical step-by-step example.
React: mistakes to avoid when using hooks
The most common mistakes to avoid when using React hooks: conditional calls, order, nested functions, and how to recognize them.
Portainer: updating your Docker instance the easy way
How to safely update your Portainer instance with a simple bash script, without losing containers or volumes.
React: useContext with useState
How to combine useContext and useState in React to share state and its update function between components, with a live example.
Crypto Miner (Coinhive) in YouTube Ads
During normal browsing on YouTube, at some point, the antivirus Avast reported something that was not good