DEV Community: Lori-Shu

Introduction to Experiment Indicators

Lori-Shu — Mon, 24 Aug 2026 15:43:57 +0000

Scientific experiments typically need clear indicators to measure and quantify performance. This is especially true in data-processing contexts, where several key metrics deserve close attention.
We can start with a few fundamentals familiar from high-school math: the average (mean), the mode, and the variance. The average corresponds to the "expectation" discussed in probability courses; it summarizes the overall property of a dataset in a single number. The mode is simply the value that appears most frequently. Variance indicates stability—if a dataset shows large variance, it is considered unstable.
Residual is another useful indicator. It measures the difference between data points that have a time-domain character. Residuals are particularly valuable in signal processing, where data are typically ordered by time. They are calculated by taking the difference between values at separate time points.
From residual we derive RSS (Residual Sum of Squares), also known as SSE (Sum of Squared Errors). RSS is obtained by squaring each residual and then summing the results. RMSE (Root Mean Squared Error) takes this a step further: it divides the RSS by the number of data points and then takes the square root. The result has the same magnitude as the original data and effectively represents the average residual. RMSE is especially powerful when the data contain both positive and negative values, because squaring prevents opposing residuals from canceling each other out.

The Trend of Modern Programming Languages

Lori-Shu — Sun, 23 Aug 2026 16:06:05 +0000

In 2026, programming languages—the core tools of software engineers—are undergoing a clear and accelerating shift: they are becoming more static.
Two major design paradigms have long shaped language design. On one side are the static-first languages such as C and Rust. These typically feature strong type systems and sophisticated, heavyweight compilers. On the other side are the dynamic-first languages such as Python and JavaScript. They traditionally rely on weaker type systems while leveraging powerful, professionally engineered runtimes.

Insight:The current trend is unmistakable: languages that once embraced dynamic features are steadily adopting more static characteristics. Many of them have borrowed ideas and mindsets from languages like Rust. Evidence shows that this shift delivers tangible benefits—faster startup times, reduced runtime memory usage, and greater code determinism.
Recognizing this evolution helps us better understand the interplay between static and dynamic elements in our own software. The practical recommendation is straightforward: prefer static approaches whenever possible, and only fall back to dynamic solutions when something is genuinely difficult to make static.

Google's Latest Talent Rearrangement

Lori-Shu — Thu, 06 Aug 2026 15:35:09 +0000

Earlier today, Jeff Dean announced his departure from Google. Who is Jeff Dean? He is one of the most influential figures in Google's history and one of the company's two legendary chief engineers. As a core technical leader, his departure sends a clear signal that Google is undergoing a significant internal talent transition. Since joining Google in 1999, Jeff Dean has contributed to nearly every major product and infrastructure initiative developed by the company. Let's revisit his remarkable journey at Google.
For general users worldwide, Jeff Dean's influence can be seen across many Google products, including Google Search, Gmail, Google Translate, YouTube, Chrome, and Gemini. Some of these products were developed directly under his technical leadership, and they have collectively shaped the digital experiences of billions of users.
For developers and engineers, Jeff Dean is widely regarded as a pioneer of large-scale computing. He played a key role in designing foundational frameworks and systems such as MapReduce, BigTable, GFS (Google File System), Pregel, and TensorFlow. Several of these innovations later inspired influential open-source projects, including Apache Hadoop MapReduce, bringing large-scale computing capabilities to developers around the world.
Insight: Jeff Dean's departure comes amid ongoing speculation about internal disagreements among Google's senior leadership. While Google may be losing one of its legendary technical figures, the broader technology ecosystem continues to benefit from the contributions of pioneers like him. The impact of such talents extends far beyond any single company, ultimately advancing the progress of the entire industry.

The Basic Animation Mechanism in Egui

Lori-Shu — Sat, 11 Jul 2026 14:02:27 +0000

As an immediate-mode UI framework, egui handles animations in a fundamentally different way from traditional retained-mode UI frameworks. Instead of maintaining an explicit animation object, egui provides helper functions such as ui.animate_bool_with_time() -> f32 to track animation progress internally.
The method takes three arguments: an Id (a unique identifier for the animation state), a Boolean flag, and a duration specified as a 32-bit floating-point value. Internally, the egui runtime caches a floating-point state associated with the given Id. This value smoothly transitions from 0.0 to 1.0, or reverses from 1.0 back to 0.0, depending on the state change of the Boolean flag.
During each repaint cycle, egui retrieves the cached animation state using the corresponding Id and updates its progress. The Boolean flag determines the animation direction, while the returned floating-point value represents the current animation progress. Developers can then use this value to control rendering parameters, such as opacity, position, or size.
Insight: Although egui's built-in animation functions are convenient, they are not always sufficient for more sophisticated animation requirements. In such cases, developers should manually manage animation progress using ui.time(). These helper animation functions implicitly maintain internal state, such as a floating-point progress variable, behind the scenes. Understanding this underlying mechanism is essential for designing more advanced animations and for gaining a deeper understanding of egui's immediate-mode paradigm.

The Transition from Code to Standard

Lori-Shu — Wed, 08 Jul 2026 16:09:37 +0000

Some software eventually evolves into an official standard. The word standard itself implies that such software has been recognized as authoritative, reliable, and widely accepted. A good example is the Opus audio codec, which was originally developed by the Xiph.Org Foundation and later standardized as an IETF (Internet Engineering Task Force) RFC. Standardization greatly accelerated the adoption of Opus, allowing it to become one of the most widely used audio codecs on the Internet.
Achieving this transition from code to standard is far from easy. Software intended for standardization must be implemented with exceptional quality, accompanied by clear specifications, and undergo extensive technical review and multiple rounds of discussion and voting before it is accepted by organizations such as the IETF.
Insight. Software that has become part of an official standard provides excellent learning material for developers. It demonstrates not only how to write high-quality code, but also how to design software that is robust, interoperable, and maintainable. As developers, striving to produce work that is eventually worthy of standardization is a meaningful long-term goal.

The Rotation Logic of an AVL Tree

Lori-Shu — Sun, 05 Jul 2026 08:35:20 +0000

Oh, my drawing is in a mess but I hope it makes sense.

Breaking： FFmpeg News

Lori-Shu — Thu, 02 Jul 2026 15:28:49 +0000

FFmpeg announced that their native AAC encoder was rewritten and achieved SOTA with respect to quality. https://x.com/FFmpeg/status/2072320220509741087?s=20

The Direct-Access Array

Lori-Shu — Wed, 01 Jul 2026 15:56:21 +0000

The Direct-Access Array is one of the simplest data structures. It stores data at the index corresponding to the value of the data itself. Typically, the stored type is a boolean flag indicating the existence of this value. Utilizing a Direct-Access Array yields optimized constant time complexity when storing and reading data (by incrementing the index and accessing the memory that the index points to). It also can be used to detect duplicates. When we try storing a number and the boolean flag is true, we find a duplicate. This characteristic can be used to replace the HashSets in the cases that the largest number is known to be bounded within a reasonable range. Aside from the replacement optimization, the special array is used in the "buckets" structure in the highly efficient Radix Sort algorithm.
Insight: Simple data structures often deliver high performance but often cannot implement sophisticated operations. We should consider these simple data structures when facing limited computational resources and pursuing highly efficient algorithms.

The Magic of Radix Sort

Lori-Shu — Mon, 29 Jun 2026 16:15:24 +0000

Radix Sort is a sorting algorithm which does not rely on comparison and achieves highly optimized time complexity of O(n). Although it is not suitable for numbers containing too many digits, we developers can leverage its speed to solve specific problems.

The genius design of Radix Sort is that it exploits the fact that a single digit has only 10 possible values (zero to nine). First, it initializes ten "buckets." Each one is designed for storing the numbers that have the corresponding digit. Second, Radix Sort uses the buckets to sort the input, which is putting the numbers in the bucket with their digits. This process has to consider the digit from the least significant digit (LSD) to the most significant digit (MSD) in order to guarantee the sorting stability and the complexity. Then the algorithm repeats the process until the sorting of the most significant digit is done. While at every cycle Radix Sort writes back the numbers to the original array, at the next time that it scans the array from the beginning, it preserves the results of the previous cycle. With this operation, the numbers which have the same lower digits won't change order unless some of them have bigger high digits and get placed to larger bucket in the remaining cycles. In addition, if we want the "bucket" to work well, we usually make it a queue so that we can push and pop elements in a FIFO (First-In, First-Out) order to maintain stability. Otherwise, we could use a standard vector and perform the write-back in reverse order.

Insight: I'm impressed by the optimized O(n) complexity of Radix Sort. It turns out that if we abandon the comparison model, the optimization of sorting algorithm can go further. For memorizing, I think it is better to emphasize the concept of "bucket" and "non-comparison-based sorting."

The Complexity of UI Layout

Lori-Shu — Sat, 27 Jun 2026 15:48:59 +0000

For backend developers like me, handling the widget layout of UI is a burden. In general, there are two mainstream layout strategies: absolute positioning and relative positioning. Frontend engineers leverage these strategies to create magic. In order to simplify and visualize the layout, developers came up with some great tools like the "DOM Tree" in HTML and anchoring and docking mechanisms in UI libraries. These tools and designs make the code logically look like the output UI, which makes it easier for developers to bridge the gap between programming abstractions and visual implementations.

Insight: In my experience, we can also leverage the decoupling idea in UI sector—treating components as independently as possible. This structural arrangement improves maintainability and accelerates the product development in the long term.

The Characteristics of Existing Graphics APIs

Lori-Shu — Fri, 26 Jun 2026 15:51:36 +0000

The Graphics APIs are responsible for connecting high-level code to drivers (one kind of low-level software which controls the external hardware). The quality and efficiency of Graphics APIs are vital to building advanced graphic environments and applications. We could classify these APIs into two kinds: platform-specific APIs and cross-platform APIs.

Platform-specific APIs are usually the most efficient APIs on the platform. They conventionally are developed along with the system development process so that they can interact with the operating system seamlessly. In addition, hardware manufacturers are willing to support them with the highest priority. Nowadays, DirectX series are the first-class APIs on Windows, which power most existing games. Metal is the current official API on macOS; however, things become far more interesting on Linux.

Cross-platform APIs are those which are capable of running on multiple platforms. A fact is that the cross-platform APIs are almost all designed for Linux at first and they are in fact the first-class APIs on Linux. However, because of the "open source" root of Linux, the APIs are able to run on other platforms, requiring minimal effort from system developers. OpenGL and Vulkan are the prominent implementations built by the Khronos Group. OpenGL is older, less efficient on large applications while the abstraction is higher and easier to use. Vulkan is more advanced with modern graphic features while the abstraction is more sophisticated and takes a lot of work to integrate in high-level applications.

Insight: Currently, the axiom is that a Graphics API cannot be both the most efficient and cross-platform. We may expect Vulkan to be the game- changer.

How Does the Backpressure Mechanism Work in mpsc::channel?

Lori-Shu — Wed, 24 Jun 2026 16:02:51 +0000

There is a powerful mechanism called "backpressure" derived from mpsc::channel. Alongside the function of data transfer, we could also utilize the channel with this mechanism to achieve a specific effect.

"Backpressure" relies on the async runtime. When a bounded channel is full, the sender will suspend the current task and yield control back to the async executor until it becomes ready again. This only works in an async context. Otherwise, the sender will just block. How can we use the phenomenon? In my experience, this can be used to automatically suspend background tasks. In most cases, the data flows in one direction. Once we control the consumer at the endpoint, the tasks along the entire pipeline are gracefully suspended. This can save a lot of work if we want to temporarily stop the consuming process and the upstream tasks. Symmetrically, it works in the scenario that we make the producer side stop sending.

Insight: There are many elegant optimizations leveraging the side effects from the original action. In addition to "backpressure", I have encountered mechanisms like storing information in the unused bits of a chunk of memory, storing static assets in the static space of an executable file etc.