How Web Bloat Impacts Users With Slow Devices
- Dan Luu tl;dr: “Modern pages that burn a ton of CPU when loading could be doing pre-work that means that later interactions on the page are faster and cheaper than on the pages that do less up-front work, but that's not the case for pages tested, which are slower to load initially, slower on subsequent loads, and slower after they've loaded.”featured in #500
Behind The Draw - How Canva's Drawing Tool Works
- Alex Gemberg tl;dr: An exploration into the evolution of Canva's drawing tool, highlighting technical challenges to improve application performance and user satisfaction. Alex discusses efforts in optimizing SVG paths, implementing state machines, and introducing native implementations for mobile platforms.featured in #497
featured in #477
featured in #476
Getting Started With Web Performance
- Alistair Shepherd tl;dr: "We’ll be diving into the river of load times and exploring what web performance is, why it’s important, how to measure it and finally my click-baity “Ten Wild Web Performance Tips! You’ll be saving number 5 for later!”. If you already know your CLS’ from your FCPs, lab from field data, and are well familiar with Lighthouses (not the ones with big lights) then you can jump straight to the tips."featured in #476
Building A Faster Hash Table For High Performance SQL Joins
- Andrei Pechkurov tl;dr: Andrei delves into QuestDB’s unique hash table, FastMap, designed to enhance SQL execution for JOIN and GROUP BY operations. FastMap employs open addressing and linear probing, optimized for high performance in database environments. It supports variable-size keys and fixed-size values, facilitating efficient data handling and updates. Notably, FastMap operates off-heap, reducing garbage collection pressure to improve performance.featured in #475
Parsing 8-Bit Integers Quickly
- Daniel Lemire tl;dr: Daniel discusses efficient methods for parsing 8-bit integers from ASCII / UTF-8 strings. The post begins by describing a basic C function for parsing 8-bit integers. This function checks if each character in the string is a digit and then calculates the integer value. It works well for strings with predictable lengths but can be inefficient when the length varies due to branch misprediction in the processor. The post also discusses an alternative version, which is presented as potentially faster under some compilers.featured in #470
Analyzing Data 170,000x Faster With Python
- Sidney Radcliffe tl;dr: The article elaborates on the process of optimizing a function in Python. Sydney begins by explaining the initial challenges faced, such as slow performance and high memory usage. To address these issues, the article suggests using libraries like NumPy and Cython. Throughout the piece, the author provides code snippets to showcase the optimization steps. By the end, performance comparisons are presented, highlighting the significant improvements achieved through the optimization process.featured in #461
Maxjourney: Pushing Dicord's Limits With A Million+ Online Users In A Single Server
- Yuliy Pisetsky tl;dr: "With that growth, those servers started slowing down and creeping ever closer to their throughput limits. As that’s happened, we’ve continued to find many improvements to keep making them faster and pushing the limits out further. In this post we’ll talk about some of the ways we’ve scaled individual Discord servers from tens of thousands of concurrent users to approaching two million concurrent users in the past few years."featured in #460
The Surprising Impact Of Medium-Size Texts On PostgreSQL Performance
- Haki Benita tl;dr: Haki’s article delves into the intricacies of text field sizes and their impact on PostgreSQL query performance. He classifies text fields into "small", "medium", and "large", highlighting the unexpected performance implications of medium-sized texts. Through the lens of PostgreSQL's TOAST mechanism, which compresses and/or breaks up large field values, Haki demonstrates that medium texts can sometimes lead to slower queries than even larger texts. "The main problem with medium-size texts is that they make the rows very wide," affecting performance due to increased IO.featured in #453