Best of Performance — September 2024

1. 1
   Article

   Community Picks·2y

   Leave useEffect Alone!

   Frontend development can be as intricate as backend work, especially when managing state and optimizing performance in React applications. The popular useEffect hook, while useful for synchronizing components with external factors, can often lead to issues like unnecessary re-renders and race conditions if misused. This post outlines common mistakes and best practices to avoid such pitfalls, offering solutions for proper cleanup, efficient data flow, and minimizing redundant renders. Guidance is provided on when it's appropriate to use useEffect, including initialization, managing external resources, and handling unmounted components without fear of memory leaks.

   266

   6
2. 2
   Article

   Community Picks·2y

   Mastering Next.js Dynamic Imports for Performance and Efficiency

   Dynamic imports in Next.js help improve performance by loading JavaScript modules asynchronously, reducing initial load times and enhancing the user experience. By leveraging techniques like code splitting and React Suspense, developers can ensure efficient and responsive web applications. Best practices include prioritizing above-the-fold content and using appropriate loading indicators.

   249

   5
3. 3
   Article

   Community Picks·2y

   Things I Wished More Developers Knew About Databases

   Effective database management involves understanding numerous critical concepts such as ACID properties, network reliability, transaction isolation levels, optimistic locking, and the impact of auto-incrementing IDs. Appreciating the complexity of database design helps in predicting potential issues like dirty reads, data loss, and write skews. Additionally, proper handling of latency, sharding, and clock skews can prevent operational surprises. It's essential to evaluate performance requirements per transaction, avoid nested transactions, and understand query planners for optimized database performance. Navigating online migrations smoothly ensures minimal downtime and accurate data migration.

   194

   4
4. 4
   Article

   Medium·2y

   The 7 Levels of Laravel Optimization: From Rookie to Optimization Overlord — with Benchmark — 98% reduction

   This post guides you through seven levels of optimizing Laravel applications, from basic eager loading to advanced techniques like lazy collections and chunking. It details each step with code examples and benchmarks, showing significant resource savings at each level.

   194

   15
5. 5
   Article

   ITNEXT·2y

   System Design Sketches

   System design sketches for various popular applications including social networks, ride-sharing apps, messaging platforms, video streaming services, file hosting apps, and web crawlers. Each sketch outlines the functional and non-functional requirements, core entities, and API endpoints. The post also provides deep dive resources for further exploration.

   189

   5
6. 6
   Article

   Community Picks·2y

   Faster Dictionary in C#

   The .NET Base Class Library's Dictionary<TKey, TValue> offers constant time access to values, but duplicated lookups can reduce efficiency. Utilizing the TryAdd method in .NET Core 2.0 can prevent duplicate lookups and boost performance. Additionally, .NET 6 introduced methods in System.Runtime.InteropServices.CollectionsMarshal to address duplicate lookup scenarios using managed pointers. These methods, alongside managed pointers and the ref keyword, can significantly speed up dictionary operations, particularly with structs and large structures. However, it's crucial to handle managed pointers cautiously to avoid potential issues with dictionary reorganization.

   139

   4
7. 7
   Article

   LogRocket·2y

   Node.js performance hooks and measurement APIs

   Node.js provides built-in performance hooks and measurement APIs to help identify and address performance bottlenecks in applications. By using these tools, developers can achieve higher precision in measuring execution times, mark key events in the code, and use Prometheus for exporting performance data. The post covers methods like performance.now, performance.mark, and performance.measure for comprehensive performance monitoring, and provides examples of optimizing database queries and sorting algorithms. It also introduces the use of worker threads for offloading computationally intensive tasks without blocking the main thread.

   133
8. 8
   Article

   Codemotion·2y

   Java Optimization: A Practical Guide to Boost Performance

   Performance optimization is vital for developing efficient Java applications. Key techniques include code profiling using tools like Java VisualVM and JProfiler, and optimizing string operations by replacing String with StringBuilder. Addressing performance challenges such as slow response times, inefficient memory usage, and excessive CPU load can significantly enhance user experience and reduce operational costs.

   133

   3
9. 9
   Video

   Community Picks·2y

   Why Good Developers Should Use Bad Computers! | Tsoding

   Developers should use less powerful computers to ensure the software is optimized for average users who do not have high-end machines. The overuse of supercomputers in development leads to bloated software that performs poorly on regular devices. Companies should enforce policies requiring developers to work with lower-end hardware to improve overall software performance and user experience.

   130

   27
10. 10
    Article

    System Design Codex·2y

    Polling Vs Webhooks

    Polling involves repeatedly requesting data from a server, which can be resource-intensive and inefficient. Webhooks, on the other hand, offer a real-time, push-based approach where a server notifies a client when new data is available. Polling can lead to missed real-time updates, while webhooks are more efficient and suitable for scenarios requiring immediate notifications. Each approach has use cases: polling for frequent but non-real-time data updates, and webhooks for scenarios where real-time data is crucial.

    129

    7
11. 11
    Article

    Community Picks·2y

    Optimizing React Performance: Strategies to Avoid Unnecessary Re-Renders

    React performance optimization is crucial for smooth user experiences. Key strategies include using React.memo to prevent unnecessary re-renders, employing useCallback to memoize callback functions, leveraging useMemo for expensive calculations, avoiding inline functions and objects, and using immutable data structures. React Developer Tools can also aid in profiling and further optimization.

    113

    1
12. 12
    Article

    Community Picks·2y

    How Indexing Enhances Query Performance

    Indexes play a crucial role in enhancing database query performance by allowing quick data retrieval without scanning the entire dataset. The post explores various types of indexes like primary, secondary, clustered, and non-clustered, and provides examples of their implementation in Spring Boot applications using JPA annotations. It also discusses scenarios where indexing is beneficial, such as high-volume read operations, frequent filtering, sorting, and join operations. Moreover, it highlights when not to use indexes, such as in low-volume tables or columns with low cardinality, and delves into how indexes operate behind the scenes, including index creation and maintenance.

    106

    4
13. 13
    Article

    ASP.NET Blog·2y

    Performance Improvements in .NET 9

    Exciting performance improvements are packed into .NET 9, making it the best and fastest release so far. More than 7,500 pull requests, with a significant focus on performance, contribute to this release. Key highlights include dynamic profile-guided optimization (PGO), enhanced just-in-time (JIT) compiler optimizations, refined tier 0 compilation, loop optimizations, and reductions in bounds checking overheads. These changes collectively enhance runtime efficiency, memory management, and overall application speed.

    99

    3
14. 14
    Article

    PostgreSQL·2y

    PostgreSQL 17 Released!

    PostgreSQL 17 has been released, offering significant performance boosts, including improved memory management, better I/O processing, enhanced query execution, and optimizations for high concurrency workloads. It introduces new developer features like the SQL/JSON `JSON_TABLE` command and enhancements in logical replication that streamline high availability management and major version upgrades. It also includes updates in partition management, foreign data wrappers, and built-in collation providers for consistent text-based queries across platforms.

    98

    1
15. 15
    Article

    Community Picks·2y

    Load Images Faster in Laravel and JavaScript

    Speeding up image loading on your website is crucial for user experience and SEO. Techniques for optimizing image loading in Laravel and JavaScript include compressing image files, using Laravel’s image caching and manipulation tools, implementing lazy loading, leveraging CDNs, converting images to WebP format, and deferring offscreen images. These strategies help reduce bandwidth usage and loading times, leading to improved overall website performance.

    93

    1
16. 16
    Article

    Hacker News·2y

    How Discord Reduced Websocket Traffic by 40%

    Discord significantly reduced its websocket traffic by almost 40% through a series of compression optimizations, including switching from zlib to zstandard with streaming compression and introducing a new passive session update method. Initially, tests showed zstandard underperforming due to the lack of streaming support. After adding streaming and fine-tuning compression parameters, zstandard outperformed zlib. Additionally, switching from sending full updates to delta updates for passive sessions further reduced bandwidth usage.

    70
17. 17
    Video

    Nick Chapsas·2y

    Stop Using FirstOrDefault in .NET! | Code Cop #021

    Nick explains why using the Find method over FirstOrDefault in .NET lists can be a misleading practice. He highlights performance comparisons and how optimizations in .NET 9 make FirstOrDefault faster, emphasizing the importance of understanding such nuances to avoid harming code and performance.

    66

    9
18. 18
    Article

    Last9·2y

    Golang Logging: A Comprehensive Guide for Developers

    Logging in Go is essential for debugging and maintaining application performance. While the standard log package offers basic functionality, third-party libraries like Zerolog and Zap provide advanced features like structured logging and configurable log levels. Implementing best practices, such as avoiding sensitive data in logs and using context-rich messages, can significantly enhance log analysis and troubleshooting. Integrating with observability platforms like ELK can further improve monitoring capabilities in production environments.

    64

    2
19. 19
    Article

    Baeldung·2y

    Why Is 2 * (i * i) Faster Than 2 * i * i in Java?

    Optimizing code can sometimes involve subtle syntax differences, such as the multiplication expressions 2 * (i * i) and 2 * i * i in Java. Even though both yield the same result, 2 * (i * i) is generally faster due to clearer order of operations, allowing better compiler optimization and more efficient CPU execution. Benchmarks confirm minor but notable performance discrepancies, especially with higher values, reinforcing the importance of understanding both language mechanics and hardware for performance-critical code.

    63

    2
20. 20
    Article

    asayer·2y

    Enhancing Web Performance with Event Delegation

    Event delegation is a technique in web development where a single event listener is attached to a parent element to handle events for its child elements, improving efficiency and code maintainability. This method is particularly useful for dynamic content and large, interactive elements like forms and lists. Key concepts include event bubbling and event propagation, which allow events to be managed efficiently without numerous individual listeners.

    62

    3
21. 21
    Article

    Collections·2y

    The 'Wrong Way' To Use React

    Data fetching in React is a contentious topic, with 'fetch on render' often criticized for inefficiency and potential performance issues. An alternative, 'render as you fetch', decouples data fetching from rendering, allowing for improved performance and user experience. Recent discussions around React 19 and Suspense highlight the evolving strategies and community debates on optimizing React applications. Incorporating server-side rendering can further enhance performance in complex applications.

    59

    24
22. 22
    Article

    freeCodeCamp·2y

    How to Transform an Angular Application with Signals

    Learn how to enhance the performance of your Angular applications using the new 'signals' feature. This tutorial provides a step-by-step guide to transform an existing timesheet management application. Key tasks include setting up signals, creating computed signals, and ensuring smooth communication between parent and child components using input, model, and output signals.

    58

    2
23. 23
    Article

    Community Picks·2y

    It's time to speed up your website with rel="preload"

    Using the HTML link rel='preload' attribute can significantly improve your website's performance by preloading critical resources like fonts, stylesheets, and scripts. This reduces render-blocking issues and improves the First Contentful Paint (FCP), enhancing the overall user experience. However, it's crucial to preload only essential assets to avoid performance degradation.

    55

    1
24. 24
    Article

    Community Picks·2y

    Interning in Go

    Go 1.23 introduces a new package, unique, for interning objects to reduce memory usage by re-using objects of equal value rather than keeping duplicates in memory. Examples include handling large strings and slicing them to create smaller substrings for efficient memory management. Interning helps in various environments like stateful web servers and batch jobs where memory resources are limited.

    52
25. 25
    Article

    Lobsters·2y

    Improving rendering performance with CSS content-visibility

    A developer encountered a performance issue with an emoji picker containing 20k custom emojis, causing significant slowdown. To address this, they explored using CSS content-visibility as an alternative to complex virtualization. By leveraging this feature and related optimizations, they achieved a 45% performance improvement in Chrome and Firefox. Despite this success, the author notes that for maximum performance, a virtual list remains ideal, though CSS content-visibility offers a simpler, accessibility-friendly interim solution.

    51

    3