Best of Performance — June 2025

1. 1
   Article

   This is Learning·45w

   Tips for Improving API Performance in ASP.NET Core

   Performance optimization techniques for ASP.NET Core APIs include using proper async/await patterns, implementing pagination for large datasets, utilizing AsNoTracking() for read-only operations, enabling response compression with Gzip or Brotli, implementing caching strategies with IMemoryCache or distributed cache, and avoiding overfetching by using DTOs. The guide provides practical code examples and warns against common pitfalls like blocking calls with .Result or .Wait().

   165

   2
2. 2
   Video

   Mental Outlaw·45w

   Linux is Destroying Windows in Gaming Performance

   Performance testing reveals Linux-based Steam OS consistently outperforms Windows 11 on identical handheld gaming hardware. The Legion Go S running Steam OS achieves higher frame rates in popular AAA games like Cyberpunk 2077 (59 vs 46 FPS) and Witcher 3 (76 vs 66 FPS), despite using Proton compatibility layer to run Windows games. Linux also delivers superior battery life, sometimes more than doubling gaming time compared to Windows. The performance advantage stems from Linux's reduced system overhead versus Windows 11's bloat, including resource-heavy components like React Native-based start menu and integrated ads/AI features.

   152

   25
3. 3
   Article

   The New Stack·42w

   Node.js 24: Your Next Big Frontend Upgrade?

   Node.js 24 brings significant improvements including native TypeScript support, better ES Module compatibility, explicit resource management for automatic cleanup, and enhanced performance through V8 optimizations. Despite these advances, many developers continue using outdated versions like Node 12 and 18, creating security risks. The update addresses long-standing JavaScript challenges with resource management and introduces Watt, an application server that enables multi-threading and even PHP integration within Node.js applications.

   137

   6
4. 4
   Video

   Theo - t3․gg·44w

   Why Tech Companies Are Moving Off React

   A detailed analysis of why some tech companies are considering moving away from React, examining the framework's evolution through hooks, concurrent mode, server components, and the React compiler. The discussion argues that React's recent developments primarily benefit large-scale applications, addressing performance issues and complexity management that big companies face. The author counters claims that React is failing at scale, demonstrating how features like hooks improved code composability, server components solve server-driven UI problems, and the compiler optimizes performance automatically.

   118

   30
5. 5
   Article

   Towards Dev·44w

   Blazing Fast Leaderboards using Redis

   A gaming platform faced severe performance issues with MySQL-based leaderboards, taking 30+ seconds to load for 1 million users. By migrating to Redis sorted sets (ZSETs), they reduced response times from 30 seconds to under 50 milliseconds. The implementation uses ZADD for storing user scores, ZCOUNT for ranking, and ZREVRANGE for pagination. While Redis dramatically improved performance, challenges remain with initial data loading for large datasets and concurrent write operations affecting query response times.

   94

   4
6. 6
   Article

   Medium·42w

   The 5 Most Surprising, Ingenious Data Structures and What They Actually Do

   Explores five advanced data structures that solve complex problems beyond basic arrays and lists: B-Trees for efficient database storage with shallow depth, Radix Trees for fast prefix-based lookups in routing, Ropes for efficient text editing in large documents, Bloom Filters for probabilistic membership testing at scale, and Cuckoo Hashing for constant-time operations using eviction strategies. Each structure addresses specific performance challenges in real-world systems.

   89

   1
7. 7
   Article

   Lobsters·43w

   The fastest way to detect a vowel in a string

   A comprehensive performance analysis of 11 different methods to detect vowels in strings using Python. The study reveals that regex methods significantly outperform traditional loops due to CPython's interpreter overhead and optimized C implementations. Through bytecode analysis and CPython source code examination, the author demonstrates how regex engines use bitmap lookups for character matching, making them surprisingly faster than simple Python loops, especially for longer strings.

   86
8. 8
   Article

   Anton Zhiyanov·42w

   JSON evolution in Go: from v1 to v2

   Go 1.25 introduces json/v2 package with significant changes from v1. Key improvements include new MarshalWrite/UnmarshalRead functions for direct I/O operations, streaming encode/decode via jsontext package, configurable options for formatting and behavior, enhanced field tags (inline, format, unknown), flexible custom marshalers with MarshalFunc/UnmarshalFunc, and changed default behaviors (nil slices/maps marshal to []/{}). Performance shows similar marshaling speed but 2.7x-10.2x faster unmarshaling. The package remains experimental requiring GOEXPERIMENT=jsonv2 flag.

   82
9. 9
   Article

   Steve Klabnik·44w

   Is Rust faster than C?

   Comparing Rust and C performance is complex because 'all things being the same' is difficult to define. While both languages can achieve similar performance through inline assembly and compiler optimizations, they differ in default behaviors like struct field ordering, bounds checking, and safety guarantees. Rust's compile-time safety checks may lead developers to write different code patterns than in C, affecting runtime performance. Social factors also play a role, as developers may be more willing to write performance-oriented code in Rust due to its safety guarantees. Fundamentally, there's no inherent reason Rust cannot match C's performance capabilities.

   75

   4
10. 10
    Article

    Netguru·42w

    Golang vs C#: Backend Battle - What Top Companies Choose

    Go and C# represent different philosophies for backend development. Go offers superior memory efficiency (25MB vs 162MB), faster initial response times, and simpler deployment with 6MB container images. C# provides a mature ecosystem, comprehensive tooling, and better enterprise integration. Go excels in microservices and cloud-native applications, while C# dominates desktop applications and enterprise systems. Performance differences narrow under sustained load, with both languages suitable for production workloads. The choice depends on team expertise, infrastructure, and specific project requirements rather than absolute performance metrics.

    74

    5
11. 11
    Article

    Hacker News·42w

    Python can run Mojo now

    Mojo can now be called from Python code, offering significant performance improvements for computationally intensive functions. The setup involves installing the modular package and creating .mojo files that export functions to Python. Benchmarks show Mojo delivering substantial speedups compared to pure Python and even NumPy implementations, though the technology is still in early development with some limitations like integer overflow issues.

    66

    4
12. 12
    Article

    habr·42w

    What May Surprise You About UUIDv7

    UUIDv7 is a 128-bit identifier inspired by ULID that combines timestamps with random data, offering superior performance and functionality compared to traditional auto-increment IDs and other identifier types. Key advantages include cryptographically secure generation, monotonicity guarantees, equivalent performance to bigint while eliminating key collision issues, and the ability to hide creation timestamps through offset options. The format supports various implementation strategies across databases like PostgreSQL and ClickHouse, with optimal storage achieved through binary format rather than string representation.

    61

    1
13. 13
    Video

    YouTube·43w

    Go just got faster..

    Go 1.25, expected in August 2025, introduces several performance improvements including the experimental Green Tea garbage collector promising 10-40% reduction in GC overhead, a new JSON v2 package that's 2.7-21x faster than the current implementation, DWARF version 5 debug information for faster compilation, and enhanced address sanitizer with leak detection. These features are currently experimental and require build-time flags to enable.

    59

    2
14. 14
    Article

    Gleam·45w

    Gleam JavaScript gets 30% faster

    Gleam v1.11.0 introduces significant performance improvements with 30% faster JavaScript compilation through optimized pattern matching using decision trees instead of linear if-else chains. The release adds new testing capabilities with built-in assert syntax, a dedicated dev/ directory for development code accessible via 'gleam dev' command, and enhanced language server features including better code actions and fault tolerance. Additional improvements include JavaScript bit array support for UTF-16/UTF-32, better documentation generation, and various developer experience enhancements.

    51

    1
15. 15
    Article

    LogRocket·42w

    How to optimize your Next.js app with after()

    Next.js 15 introduces the after() API that allows developers to run background tasks after sending responses to clients, improving performance by preventing non-critical operations from blocking user interactions. The function works across Server Components, Server Actions, route handlers, and middleware, each with different capabilities and access to request data. It executes tasks in reverse order when nested, runs even during errors, and provides a clean alternative to cramming side effects into main request logic or using complex background job setups.

    48

    2
16. 16
    Article

    Medium·45w

    Laravel Under Pressure: High-Traffic Optimization with Cache, Queue & Session Tactics

    Laravel applications can handle high traffic effectively when properly configured. Key optimizations include switching from file-based to Redis caching, using proper queue drivers instead of database queues, implementing route/config/view caching, managing sessions with Redis, and ensuring stateless architecture for horizontal scaling. The guide covers practical tactics like eager loading to prevent N+1 queries, batch job processing, rate limiting, and proper monitoring tools for production environments.

    39

    1
17. 17
    Article

    Syncfusion·43w

    7 Underrated C# 12 and C# 13 Features Every Developer Should Know!

    C# 12 and C# 13 introduce several underrated features that significantly improve code quality and performance. Key highlights include collection expressions for cleaner syntax, inline arrays for memory optimization, ref readonly parameters for efficient struct handling, type aliases for complex generics, typed exceptions for better error handling, params span for allocation-free variadic functions, and warning wave 7 for code quality improvements. These features enhance developer productivity while preparing codebases for C# 14's upcoming capabilities.

    36
18. 18
    Article

    Hacker News·45w

    10 years of betting on Rust

    A founder reflects on 10 years of using Rust in production, from the painful early days of version compatibility issues and compile time problems to today's mature ecosystem. Despite initial challenges with the borrow checker and tooling, Rust has evolved into a reliable choice for systems programming with exceptional community support, predictable builds, and excellent developer experience. The author discusses future improvements including faster compilation, better portability, ubiquitous const evaluation, simpler concurrency models, and expansion into new domains like web development and machine learning.

    36
19. 19
    Article

    Medium·43w

    The Art of Doing Everything All at Once in Python! Hence, Multithreading.

    Python's map(), filter(), and reduce() functions provide functional programming alternatives to traditional loops for data transformation and filtering. Multithreading enables concurrent execution of tasks, particularly useful for I/O-bound operations, though Python's Global Interpreter Lock (GIL) limits true parallelism for CPU-intensive tasks. Thread synchronization using locks prevents race conditions when multiple threads access shared resources. These concepts become essential for building scalable, performant applications beyond simple scripts.

    34
20. 20
    Article

    Community Picks·41w

    kelindar/event: Simple internal event bus for Go applications

    kelindar/event is a high-performance, in-process event dispatcher library for Go that enables decoupling of modules through event-driven patterns. It processes millions of events per second with 4x to 10x better performance than channels, supports both synchronous and asynchronous processing, and works with any type implementing the Event interface. The library provides both a default global dispatcher and specific dispatcher instances, making it ideal for lightweight pub/sub patterns within single Go processes while being unsuitable for inter-service communication or event persistence scenarios.

    30
21. 21
    Video

    Nick Chapsas·42w

    My 100 Tips for Better .NET Code

    A comprehensive collection of 100 practical C# and .NET development tips covering performance optimization, memory management, async programming, language features, and best practices. Topics include proper exception handling, LINQ optimization, dependency injection, modern C# syntax features like primary constructors and collection expressions, testing strategies, and common pitfalls to avoid. The tips range from basic concepts like proper null checking to advanced topics like ref structs, span usage, and memory allocation optimization.

    26

    3
22. 22
    Article

    Laravel News·43w

    Manipulate Image URLs in Laravel with the Image Transform Package

    A new Laravel package called laravel-image-transform-url provides a lightweight solution for manipulating images through URL parameters. Inspired by Cloudflare Images, it allows developers to transform images on-the-fly by appending query parameters for width, quality, format, and other modifications. The package includes built-in performance features like automatic caching, storage of processed images, rate limiting, and CDN integration support. It uses Intervention Image for file manipulations and offers a self-hosted alternative to external image processing services.

    22

    1
23. 23
    Video

    Awesome·43w

    Go just got a massive speed upgrade...

    Go's new Green Tea garbage collector represents a significant performance improvement, reducing GC overhead by 35% through span-based memory scanning instead of individual object traversal. The new approach scans 8KB memory blocks containing same-sized objects, improving spatial locality and reducing cache misses. While highly effective for small objects, Green Tea may underperform in specific scenarios like workloads with poor locality or rapidly changing tree structures.

    20

    2
24. 24
    Article

    Collections·43w

    Introducing Laravel Nightwatch: Advanced Monitoring for Laravel Applications

    Laravel Nightwatch is a new monitoring service designed specifically for Laravel applications, offering advanced production-grade monitoring capabilities beyond Laravel Telescope and Pulse. It provides deep performance insights, real-time visibility, comprehensive tracking of requests and events, and scalable architecture handling billions of events. The service features a free tier supporting 200k events monthly, with paid plans starting at $20/month for 5M events, making it accessible for projects of all sizes.

    19

    3
25. 25
    Article

    Foojay.io·42w

    Benchmark and profiling Java with JMH

    JMH (Java Microbenchmark Harness) provides accurate performance measurement for Java applications by handling JVM optimizations that can skew results. The framework offers different benchmark modes (throughput, average time, single shot, sample time), state management with @State and @Setup annotations, and integration with async profiler for detailed performance analysis. Key considerations include preventing dead code elimination using Blackhole, avoiding constant folding with variable data, and using flame graphs to identify performance bottlenecks beyond just timing measurements.

    18