72 posts · page 1 of 2
Create your own GitHub Actions from scratch using JavaScript, Docker containers, and composite steps. Includes publishing to the marketplace.
Understand how the JavaScript event loop handles async operations including the call stack, microtasks, macrotasks, and execution order with practical examples.
Learn how to use JavaScript structuredClone for deep copying objects, when it beats JSON.parse(JSON.stringify()), and what types it supports and cannot handle.
Learn the most useful JavaScript design patterns with practical examples including Singleton, Observer, Factory, Strategy, and more for cleaner code.
Learn how to detect, diagnose, and fix JavaScript memory leaks using Chrome DevTools heap snapshots, allocation timelines, and common leak patterns.
Master JavaScript Proxy and Reflect API for metaprogramming with practical examples including validation, observable objects, and access control patterns.
Master the JavaScript Streams API to process large files, network responses, and data pipelines incrementally without loading everything into memory.
Learn how to use JavaScript Web Workers to run CPU-intensive code off the main thread, keeping your UI responsive with practical examples and patterns.
Compare Node.js, Deno, and Bun on performance, security, compatibility, and developer experience. Choose the right JavaScript runtime for 2026.
Compare Jest and Vitest for JavaScript testing. Understand speed, configuration, compatibility, and migration tradeoffs to pick the right test runner.
Learn the Decorator pattern in JavaScript -- wrap functions and classes to add logging, caching, validation, and retry logic without modifying original code.
Master JavaScript error handling with custom error classes, async error patterns, Result types, error boundaries, and strategies for robust production code.
Learn how to use WeakRef and FinalizationRegistry for custom cleanup callbacks, weak caching, and observing garbage collection in JavaScript.
Understand Module Federation for micro-frontends -- share dependencies at runtime, load remote modules dynamically, and compose independent apps into one.
Implement the Observable pattern in JavaScript to build reactive event streams, compose data pipelines, and manage async flows without third-party libraries.
Use the Performance API to measure load times, mark custom timings, observe long tasks, and profile real-user performance in JavaScript applications.
Master all four JavaScript Promise combinators -- Promise.all, allSettled, race, and any -- with practical patterns for concurrency, timeouts, and resilience.
Learn how to use SharedArrayBuffer and Atomics to share memory between threads, coordinate Web Workers, and build lock-free data structures in JavaScript.
Process data incrementally with the JavaScript Streams API -- ReadableStream, WritableStream, TransformStream, and practical patterns for large data handling.
Master JavaScript Symbols for unique property keys, explore well-known symbols like Symbol.iterator and Symbol.toPrimitive, and learn metaprogramming patterns.
Master AbortController in JavaScript -- cancel fetch requests, debounce events, set timeouts, and build cancellable async workflows.
Visualize how the JavaScript event loop works -- understand the call stack, microtask queue, macrotask queue, and execution order.
Master JavaScript generators and iterators -- learn function*, yield, Symbol.iterator, and how to build custom iterable objects.
Master the JavaScript Intl API for locale-aware formatting of numbers, currencies, dates, relative time, and list conjunctions.
Explore pattern matching in JavaScript today with switch(true), and preview the TC39 pattern matching proposal for cleaner conditional logic.
Learn JavaScript private class fields with #, static blocks, private methods, and how they compare to closures and WeakMap patterns.
Learn how to use JavaScript Proxy and Reflect to intercept operations, build validators, create observable objects, and write metaprogramming patterns.
Explore the Temporal API for JavaScript -- a modern, immutable, and time-zone-aware replacement for the legacy Date object.
Understand JavaScript WeakMap and WeakSet, their garbage collection behavior, and practical use cases like caching, private data, and DOM metadata.
A deep dive into JavaScript iterators and generators: the iterator protocol, Symbol.iterator, generator functions, yield, async generators, and practical patterns for lazy evaluation and data pipelines.
Run JavaScript in background threads with Web Workers — dedicated workers, shared workers, message passing, and offloading heavy computation.
A practical comparison of ES Modules and CommonJS: how they load, how they differ, interop strategies, and how to choose for a new project.
Master async iterators in Node.js for streaming files, paginated APIs, and backpressure-aware data processing.
Find and fix memory leaks in Node.js using heap snapshots, sampling, and a few reliable patterns to avoid leaks.
Set up structured, high-performance logging in Node.js with Pino, including child loggers, redaction, and pretty-printing for development.
Understand when to reach for child processes, worker threads, or the cluster module to scale Node.js workloads.
Learn how to write reliable end-to-end tests with Playwright, including selectors, fixtures, auto-waiting, and patterns that avoid flakiness.
A practical guide to Vitest, the testing framework built for modern JavaScript projects. Setup, syntax, mocking, coverage, and how it differs from Jest in ways that matter.
Master the three most powerful array methods in JavaScript — map, filter, and reduce — with practical examples, chaining patterns, and performance tips.
Master async and await in JavaScript — write asynchronous code that reads like synchronous code, handle errors with try/catch, and parallelize work with Promise.all.
Understand JavaScript closures and lexical scope — see how inner functions remember outer variables, and learn the patterns that closures enable.
Go beyond the basics of JavaScript promises — explore the microtask queue, error propagation, cancellation patterns, and advanced combinators like any and allSettled.
Demystify the JavaScript this keyword — understand how it changes by call site, why arrow functions differ, and how to bind context without surprises.
Learn how to use React's Context API to share state across your component tree without prop drilling — with patterns, performance tips, and common mistakes to avoid.
Learn powerful patterns for building React custom hooks — extracting logic, composing hooks, handling cleanup, and designing clean APIs your team will love.
A practical deep dive into useState, useEffect, useMemo, useCallback, and useRef. Learn when to reach for each hook and the traps that ruin React code.
Avoid the most common useEffect mistakes — missing dependencies, infinite loops, stale closures, and effects that should not be effects in the first place.
An approachable introduction to TypeScript generics — learn type parameters, constraints, defaults, and how to build reusable type-safe functions and components.