Best of Performance — October 2025

1. 1
   Article

   freeCodeCamp·24w

   How to Improve Your Programming Skills by Building Games

   Building games teaches essential programming skills that extend beyond game development. Through creating games, developers learn systems thinking, event-driven architecture, performance optimization, and debugging complex states. Games force practical application of math concepts like vectors and trigonometry, while teaching component-based architecture similar to modern frameworks. The hands-on experience with user input handling, reusable code patterns, and creative problem-solving translates directly to building better web applications, backend services, and software systems. Even simple 2D games provide valuable lessons in modular design, UX instincts, and managing code complexity that traditional tutorials rarely offer.

   287

   19
2. 2
   Article

   React Native·27w

   A New Era · React Native

   React Native 0.82 marks a major milestone by exclusively running on the New Architecture, removing support for the Legacy Architecture. The release introduces experimental Hermes V1 with performance improvements (up to 9% faster bundle loading), upgrades to React 19.1.1 with full owner stacks support, and implements DOM Node APIs for web-like tree traversal. Additional features include Web Performance APIs in canary, an optimized debug build type for Android that runs at 60 FPS versus 20 FPS in standard debug mode, and improved error reporting for uncaught promise rejections.

   260

   20
3. 3
   Video

   Let's Get Rusty·24w

   Rust intern saved TikTok $300K

   A TikTok intern rewrote CPU-intensive payment service endpoints from Go to Rust, reducing average latency by 30%, P99 latency by 76%, and cutting compute costs by 50%—saving $300K annually. The migration used a gradual rollout strategy with separate Rust clusters under the same service name, avoiding upstream code changes. Key challenges included adapting Go's zero values to Rust's Option enum and optimizing memory allocations. The main lesson: Rust delivers performance gains at the cost of developer productivity, making it ideal for high-usage, stable components where economies of scale justify the rewrite effort.

   247

   30
4. 4
   Video

   Fireship·26w

   React wants to win you back…

   React 19.2 introduces useEffectEvent hook to simplify effect dependencies and an Activity component for smarter component visibility management. The React compiler reached 1.0, automating memoization optimizations that developers previously handled manually with useMemo and useCallback. React and React Native are moving to an independent foundation after 15 years under Meta. Meanwhile, the Remix team announced Remix 3, a new framework built on web fundamentals without React's legacy baggage.

   90

   14
5. 5
   Article

   Prismic·27w

   CSS Alternatives to JavaScript: Sliders, Dialogs & More!

   Modern CSS can now handle many UI components that traditionally required JavaScript, including accordions, modals, tooltips, carousels, and dropdown menus. Using CSS-only solutions offers better performance, faster load times, improved maintainability, and fewer dependencies. The guide demonstrates how to build common interactive components using modern CSS features like :has(), :checked, :target selectors, and CSS animations, while comparing them to their JavaScript equivalents. Best practices include checking browser support, ensuring accessibility, using progressive enhancement, and choosing the right tool based on complexity requirements.

   77

   4
6. 6
   Video

   bigboxSWE·24w

   Why were 90s programmers so legendary?

   Explores why 1990s programmers like John Carmack, Linus Torvalds, and Richard Stallman became legendary figures. The era's severe hardware constraints—limited RAM, slow processors, and scarce resources—forced developers to write highly optimized code and build tools from scratch. Without modern conveniences like package managers, AI assistants, or abundant tutorials, programmers had to master low-level optimization techniques, including manual memory management and assembly code. While the problems were simpler in scope compared to today's distributed systems, the technical challenges were significantly harder, creating a generation of developers with deep systems knowledge.

   70

   20
7. 7
   Article

   Hacker News·26w

   Why Is SQLite Coded In C

   SQLite remains implemented in C because it provides optimal performance, universal compatibility across platforms and languages, minimal runtime dependencies, and stability. C enables SQLite to be called from any programming language, requires only basic standard library functions, and avoids the complexity of modern language runtimes. While safe languages like Rust are acknowledged as potential future options, the SQLite team prioritizes mature, well-understood languages and notes that recoding would likely introduce more bugs than it would fix. The article addresses common questions about why SQLite wasn't built with object-oriented languages or modern safe alternatives.

   71

   21
8. 8
   Article

   MongoDB·28w

   The 10 Skills I Was Missing as a MongoDB User

   A developer shares lessons learned from transitioning from relational databases to MongoDB, covering common mistakes like improper data modeling (over-normalizing then over-embedding), ineffective indexing strategies, and reactive monitoring. The piece walks through how understanding document modeling patterns, query optimization with explain plans, aggregation pipelines, and proactive monitoring transformed their MongoDB experience from frustrating to efficient. MongoDB's new Skill Badges program is highlighted as a structured learning path that covers these fundamental skills.

   71

   3
9. 9
   Article

   Collections·28w

   Introducing React 19.2: Key Features and Enhancements

   React 19.2 introduces several performance and developer experience improvements including the Activity component for state preservation, useEffectEvent hook for cleaner event handling, enhanced Chrome DevTools performance tracking, Partial Pre-rendering for optimized load times, and improved server-side rendering with batched Suspense boundaries. Additional updates include cacheSignal for SSR cleanup, React Native enhancements with Amazon Vega OS support, Next.js 16 defaulting to Turbopack, and NativeWind 5.0 adding Tailwind 4 support.

   63

   5
10. 10
    Article

    greenonsoftware·24w

    Fixing IntelliSense Performance Issues in Nx and Turborepo

    A debugging story about resolving severe IntelliSense slowdowns in an Nx monorepo. The root cause was traced to the next-intl library generating massive TypeScript union types that overwhelmed the TypeScript language server. The investigation used git bisection to narrow down when performance degraded, ruling out project size, cyclic dependencies, and configuration issues. The solution involved removing problematic type definitions, highlighting how complex type unions and generated types can create IDE performance bottlenecks in large codebases.

    52

    8
11. 11
    Article

    Phoronix·25w

    Valkey 9.0 Released With Ability To Achieve One Billion Requests / Second

    Valkey 9.0 has been released, marking a major milestone for the Linux Foundation-backed Redis fork. The new version introduces significant performance improvements, with the capability to handle up to one billion requests per second. This key-value database continues to evolve as a popular alternative in the data storage ecosystem.

    48

    1
12. 12
    Article

    Groww Engineering·28w

    Building 915: Inside Groww’s High-Performance Trading Terminal

    Groww Engineering built 915.Trade, a high-performance web-based trading terminal for professional traders. The platform features a modular architecture with real-time data streaming using binary messaging, Zustand for optimized state management, and React Compiler for automatic optimization. Key features include direct chart trading, dynamic option chains with live Greeks, a unique straddle chart for volatility tracking, and a scalper widget with keyboard shortcuts. The system uses an EventBus with BroadcastChannel API for widget linking across tabs, enabling traders to create synchronized, shareable workspace layouts.

    46

    1
13. 13
    Article

    The New Stack·28w

    Stop Ignoring the Browser: The Biggest Frontend Shift in a Decade

    Modern browsers now natively support features that once required frameworks like React and Angular. Native APIs for routing, state management, component isolation, and animations are reducing the need for heavy framework dependencies. While frameworks still offer value through conventions and ecosystem support, they're shifting from necessity to preference. Standards-based development using Shadow DOM, ES modules, Navigation API, and Web Components can deliver better performance with smaller bundle sizes, especially for mobile and edge computing environments. The web platform has matured enough to handle modern application development without framework intermediaries.

    45

    7
14. 14
    Article

    Hashrocket·24w

    PostgreSQL 18's UUIDv7: Faster and Secure Time-Ordered IDs

    PostgreSQL 18 introduces native support for UUIDv7, a new identifier format that combines the security benefits of random UUIDs with time-based ordering. Unlike UUIDv4's completely random values, UUIDv7 embeds timestamps in the first portion, enabling chronological sorting without separate created_at columns and improving index performance by reducing fragmentation. The format maintains collision resistance and security against enumeration attacks while delivering better database performance through sequential-like insertion patterns.

    42
15. 15
    Article

    LogRocket·26w

    React 19.2 is here: Activity API, useEffectEvent and more

    React 19.2 introduces the Activity API for efficiently hiding and restoring UI state without unmounting components, and the useEffectEvent Hook for creating stable event handlers that access latest state without dependency array issues. The release includes cacheSignal API for managing cached fetch lifetimes, partial pre-rendering for faster initial loads, batched Suspense boundary reveals for SSR, and Performance Tracks in Chrome DevTools. Additional improvements include updated ESLint rules with flat config support, Web Streams API support for Node.js, and a new useId prefix format for better CSS compatibility.

    42

    2
16. 16
    Article

    ClickHouse·25w

    How Netflix optimized its petabyte-scale logging system with ClickHouse

    Netflix processes 5 petabytes of logs daily using ClickHouse, handling 10.6 million events per second with sub-second query performance. Three key optimizations enabled this scale: replacing regex-based log fingerprinting with generated lexers (8-10x faster), implementing custom native protocol serialization for efficient data ingestion, and sharding tag maps to reduce query times from 3 seconds to 700ms. The system combines ClickHouse for hot data with Apache Iceberg for long-term storage, making logs searchable within 20 seconds while serving 500-1,000 queries per second across 40,000+ microservices.

    40

    1
17. 17
    Article

    Jake Archibald·25w

    Importing vs fetching JSON

    JSON module imports are now baseline across browsers, but they have important behavioral differences from fetch(). Module imports cache data for the page lifetime and can cause memory leaks with dynamic data or large objects, while fetch() allows garbage collection. Error handling with fetch() also provides better introspection through response status and text fallbacks. JSON imports work best for local static resources that bundlers can optimize, but fetch() remains the better choice for API calls and dynamic data.

    37
18. 18
    Article

    Nuxt·25w

    Nuxt 4.2 · Nuxt Blog

    Nuxt 4.2 introduces abort control for data fetching with AbortController signals, enhanced development error pages showing both custom pages and technical overlays, and experimental TypeScript plugin support for improved DX. The release includes opt-in Vite Environment API support, a new @nuxt/nitro-server package for modular server integration, and experimental async data handler extraction that can reduce bundle sizes by up to 39% for static sites. Performance improvements include precomputed renderer dependencies and reduced package dependencies, along with fixes for route hash preservation and component auto-imports.

    36
19. 19
    Article

    Telerik·27w

    The Web Animation API

    The Web Animation API (WAAPI) is a browser-native JavaScript API that provides programmatic control over animations without external dependencies. Unlike CSS transitions and animations, WAAPI offers runtime control through methods like play(), pause(), and playbackRate(), plus the ability to chain animations using promises. The tutorial covers keyframes, timing options, interactive controls, and performance considerations—emphasizing that animating transform and opacity properties ensures smooth 60 FPS performance by leveraging GPU compositing instead of triggering expensive layout recalculations.

    36
20. 20
    Article

    Laravel Dev·28w

    Quick Wins to Speed Up Your Laravel App

    Five practical optimization techniques for Laravel applications: implementing configuration and route caching, fixing N+1 database queries with eager loading and proper indexing, offloading heavy tasks to queues, enabling OPcache for PHP compilation, and removing unused dependencies. These straightforward improvements can significantly boost application performance without complex refactoring.

    36
21. 21
    Article

    Astro·25w

    Astro 5.15

    Astro 5.15 introduces automatic skew protection for Netlify deployments to prevent version mismatches between client and server during deployments. The release adds new adapter APIs that allow hosting platforms to customize fetch headers and asset query parameters, enabling Vercel to also implement reliable skew protection. Font preloading now supports granular filtering by weight, style, and subset for better performance optimization. Additional improvements include a copy button for stack traces in the error overlay and automatic wrangler.jsonc scaffolding for Cloudflare integration.

    34

    2
22. 22
    Video

    Awesome·26w

    The new WASM 3 release is huge for web devs...

    WebAssembly 3.0 introduces major improvements including 64-bit memory addressing, native garbage collection, tail call optimization, and overhauled exception handling. These features enable languages like Rust to compile more efficiently for the browser without JavaScript workarounds. The release transforms WebAssembly from a compilation target into a genuine multi-language runtime environment, with practical applications ranging from client-side image processing to running full databases in the browser.

    34

    2
23. 23
    Video

    Jack Herrington·25w

    Master React 19.2 Async Everywhere — Boost Performance

    React 19.2 introduces comprehensive async capabilities including Suspense, the use hook, useTransition, and view transitions. The guide demonstrates migrating from traditional useEffect patterns to modern async patterns, showing how Suspense catches thrown promises to manage loading states, how useTransition enables action props for better UX, and how view transitions provide GPU-accelerated animations. Includes practical examples using TanStack Start and comparisons with TanStack Query as an alternative approach.

    33
24. 24
    Article

    Laravel News·24w

    Optimizing Queries with Memoization

    Duplicate cache calls waste time even when cached. Laravel's Cache::memo() stores results in memory during a single request, eliminating redundant cache reads. Using Laravel Telescope to identify duplicate cache hits, you can implement memoization to reduce three 8ms cache calls down to one, with minimal code changes through a MemoizedCacheService wrapper.

    31
25. 25
    Article

    Josh W Comeau·24w

    Springs and Bounces in Native CSS • Josh W. Comeau

    The linear() timing function enables physics-based animations like springs and bounces in native CSS without JavaScript libraries. By specifying multiple data points instead of Bézier curves, developers can create smooth, natural motion that runs on the GPU. The article covers implementation techniques, performance testing results showing minimal impact, limitations around time-based constraints and animation interrupts, and best practices for using CSS variables with @supports fallbacks for browser compatibility.

    29

    1