BestHub
Sign in
Tagged articles
47 articles
Page 1 of 1
Deepin Linux
Deepin Linux
May 11, 2026 · Fundamentals

Eliminate Memory Fragmentation: Understanding Memory Pools

The article explains how frequent dynamic allocations cause external and internal memory fragmentation, illustrates the problem with C++ examples, and shows that pre‑allocating a large contiguous block as a memory pool—managed via block division, free‑list tracking, and thread‑safe operations—significantly reduces fragmentation, improves allocation speed, and boosts concurrency performance.

Memory Fragmentationallocationc++
0 likes · 30 min read
Eliminate Memory Fragmentation: Understanding Memory Pools
Deepin Linux
Deepin Linux
Apr 11, 2026 · Fundamentals

Why Memory Barriers Are the Hidden Foundation of Linux Kernel Concurrency

This article explains what memory barriers are, why they are essential for correct multi‑core operation in the Linux kernel, how different barrier types work, their implementation details, and practical guidelines for using them safely in synchronization primitives and driver code.

Linux kernelSynchronizationSystem Programming
0 likes · 47 min read
Why Memory Barriers Are the Hidden Foundation of Linux Kernel Concurrency
Liangxu Linux
Liangxu Linux
Nov 17, 2025 · Fundamentals

30 Proven C Optimization Tricks to Supercharge Embedded Code Performance

This article presents a comprehensive collection of low‑level C optimization techniques for embedded systems, covering algorithm selection, data type choices, arithmetic shortcuts, loop transformations, structure layout, function inlining, register usage, and many practical code examples to dramatically improve execution speed and reduce code size.

C ProgrammingCode Optimizationembedded systems
0 likes · 26 min read
30 Proven C Optimization Tricks to Supercharge Embedded Code Performance
Lin is Dream
Lin is Dream
Oct 20, 2025 · Fundamentals

From Philosophy to Bits: A Minimalist Computer History and Bitwise Operator Mastery

This article traces the evolution of computers from philosophical logic to modern digital circuits, explains how logical gates enable computation, introduces bitwise operators with practical code examples, and analyzes a coupon‑code generation algorithm that combines masking, shifting, and XOR operations for secure identifier creation.

algorithm analysisbitwise-operatorscomputer history
0 likes · 12 min read
From Philosophy to Bits: A Minimalist Computer History and Bitwise Operator Mastery
Liangxu Linux
Liangxu Linux
Jun 25, 2025 · Fundamentals

Why Hard-Coding Memory Addresses Is a Nightmare and How Symbols Solve It

The article explains how manually calculating absolute memory addresses for functions leads to error‑prone maintenance, introduces the concept of symbols to reference code by name, and details the role of object files, symbol tables, relocation tables, and the linking process that resolves addresses automatically.

CompilationLinkerlow‑level programming
0 likes · 8 min read
Why Hard-Coding Memory Addresses Is a Nightmare and How Symbols Solve It
Liangxu Linux
Liangxu Linux
Apr 29, 2025 · Fundamentals

How Early Computers Invented Interrupts to End Wasteful Polling

The article explains how 1960s batch systems suffered from CPU waste due to polling I/O devices, how IBM 704’s overflow flag inspired automatic error handling, and how the concept evolved into hardware interrupts with a concrete design, interrupt types, and vector table implementation.

CPUInterruptsOperating Systems
0 likes · 7 min read
How Early Computers Invented Interrupts to End Wasteful Polling
Liangxu Linux
Liangxu Linux
Apr 16, 2025 · Fundamentals

How Early Programmers Imagined the Birth of Operating Systems

A nostalgic narrative explains how low‑level hardware control led to the invention of system calls, kernel/user modes, and ultimately the operating system concept, illustrating the transition from direct hardware manipulation to abstracted library functions.

System Callhardware abstractionkernel-mode
0 likes · 5 min read
How Early Programmers Imagined the Birth of Operating Systems
Liangxu Linux
Liangxu Linux
Jan 19, 2025 · Fundamentals

Why Most Operating Systems Are Written in C: Hidden Advantages Explained

This article explains why C remains the dominant language for operating system development, highlighting its simplicity, portability, lack of runtime dependencies, direct hardware control, and the transparency it offers programmers when working close to the metal.

C languageOperating SystemsSystems Programming
0 likes · 6 min read
Why Most Operating Systems Are Written in C: Hidden Advantages Explained
Deepin Linux
Deepin Linux
Jan 3, 2025 · Fundamentals

Understanding the Linux Kernel Exception Table __ex_table and Its Role in Exception Handling

This article provides a comprehensive overview of the Linux kernel's exception handling mechanism, focusing on the __ex_table data structure, its creation via macros, how the kernel locates and executes fix‑up code, and the supporting APIs and sorting process that ensure reliable recovery from faults.

Exception Handling__ex_tablekernel-development
0 likes · 21 min read
Understanding the Linux Kernel Exception Table __ex_table and Its Role in Exception Handling
IT Services Circle
IT Services Circle
Oct 27, 2024 · Fundamentals

Why Assembly Language Is the Ultimate Programming Tool

The article explains how assembly language serves as the foundational layer beneath all high‑level languages, illustrating its essential role in translating code to machine instructions, and argues that understanding assembly deepens comprehension of computer architecture despite its rare direct use today.

Assemblycomputer architecturelow‑level programming
0 likes · 8 min read
Why Assembly Language Is the Ultimate Programming Tool
dbaplus Community
dbaplus Community
Jul 14, 2024 · Fundamentals

Why Some Nordic Programmers Build Entire OSes in Assembly – The Story of MenuetOS

MenuetOS, a fully assembly‑written operating system created by Finnish developer Ville M. Turjanmaa, showcases how a single programmer can build a complete kernel, TCP/IP stack, GUI, and even run classic games, illustrating the Nordic culture of hobbyist OS development and the trade‑offs of assembly‑only design.

AssemblyMenuetOSOperating System
0 likes · 6 min read
Why Some Nordic Programmers Build Entire OSes in Assembly – The Story of MenuetOS
Liangxu Linux
Liangxu Linux
Dec 13, 2023 · Fundamentals

Why Pointers Matter: A Visual Journey from Memory Cells to C Code

This article walks through a visual memory model, introduces a simple mov instruction, expands it with size‑specific variants, explains variables and their types, and then builds up the concept of pointers, their arithmetic, and how they map to actual CPU instructions.

C languageMemory ModelVariables
0 likes · 18 min read
Why Pointers Matter: A Visual Journey from Memory Cells to C Code
Liangxu Linux
Liangxu Linux
Nov 20, 2023 · Fundamentals

How Memory, Variables, and Pointers Work from First Principles

This article explains how to read and write a tiny 8‑byte memory without any high‑level language or OS, introduces the concept of variables as named memory addresses, shows how pointers store addresses instead of copying data, and demonstrates indirect addressing and linked‑list structures.

AssemblyMemoryVariables
0 likes · 9 min read
How Memory, Variables, and Pointers Work from First Principles
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Oct 5, 2023 · Backend Development

Mastering Java Unsafe: Low-Level Memory Tricks and Atomic Operations

This article introduces Java's sun.misc.Unsafe class, explains its memory, CAS, thread, class, and object manipulation APIs, shows how to obtain an Unsafe instance, and provides practical code examples for low‑level operations such as field offsets, compare‑and‑swap, object allocation, and custom atomic counters.

atomic operationsconcurrencyjava
0 likes · 9 min read
Mastering Java Unsafe: Low-Level Memory Tricks and Atomic Operations
Liangxu Linux
Liangxu Linux
Jul 2, 2023 · Fundamentals

Why Modern Programmers Ignore CPU and Memory: Exploring Computing Fundamentals

The article reflects on how programming has become increasingly abstract, causing developers to overlook the CPU, memory, and low‑level architecture, and argues that revisiting these fundamentals is essential for deeper technical competence in today's software industry.

CPUcomputer architecturelow‑level programming
0 likes · 9 min read
Why Modern Programmers Ignore CPU and Memory: Exploring Computing Fundamentals
IT Services Circle
IT Services Circle
Jun 26, 2023 · Fundamentals

Why Modern Programmers Rarely Consider the CPU: Reflections on Low‑Level Computing

The article reflects on why modern programmers seldom think about the CPU, tracing the historical shift from assembly to high‑level languages, and argues that understanding low‑level architecture, registers, and memory remains essential despite the growing abstraction layers in software development.

CPUcomputer architecturelow‑level programming
0 likes · 6 min read
Why Modern Programmers Rarely Consider the CPU: Reflections on Low‑Level Computing
Tencent Cloud Developer
Tencent Cloud Developer
Aug 8, 2022 · Fundamentals

Deep Dive into Function Call Implementation: From Assembly to CPU Registers

This article thoroughly explains low‑level function call implementation, covering Intel and AT&T assembly syntax, the evolution of CPU registers from 16‑bit to 64‑bit x86, caller‑ and callee‑saved conventions, stack‑based to register‑based parameter passing, stack frame setup, and assembly representations of control structures.

Assembly LanguageCPU architectureCPU registers
0 likes · 23 min read
Deep Dive into Function Call Implementation: From Assembly to CPU Registers
Code Ape Tech Column
Code Ape Tech Column
Jun 1, 2022 · Fundamentals

Understanding sun.misc.Unsafe: Construction, Core Functions, and Practical Use Cases

This article explains the purpose, construction, and key functionalities of Java's sun.misc.Unsafe class, covering memory management, object allocation, class definition, offset handling, array operations, thread scheduling, CAS, and memory fences, while also showing how to obtain an Unsafe instance via reflection.

Memory ManagementReflectionconcurrency
0 likes · 11 min read
Understanding sun.misc.Unsafe: Construction, Core Functions, and Practical Use Cases
TAL Education Technology
TAL Education Technology
May 19, 2022 · Fundamentals

Learning 8086 Assembly Language: Environment Setup, Sample Program, Registers, Instruction Classification, and Execution Mechanism

This tutorial guides readers through installing a DOS environment, writing and analyzing a simple 8086 assembly program, understanding pseudo‑instructions, registers, instruction categories, execution flow, and data addressing, providing links and code examples for hands‑on learning.

8086AssemblyInstruction Set
0 likes · 5 min read
Learning 8086 Assembly Language: Environment Setup, Sample Program, Registers, Instruction Classification, and Execution Mechanism
Zhuanzhuan Tech
Zhuanzhuan Tech
Mar 28, 2022 · Backend Development

Understanding Java's sun.misc.Unsafe: Construction, Core Functions, and Usage

This article explains the purpose, construction, and most important capabilities of Java's sun.misc.Unsafe class—including memory management, object instantiation, class loading, offset handling, array operations, thread scheduling, CAS, and memory fences—while providing code examples and practical guidance for developers.

Memory Managementjavalow‑level programming
0 likes · 12 min read
Understanding Java's sun.misc.Unsafe: Construction, Core Functions, and Usage
Tencent Cloud Developer
Tencent Cloud Developer
Mar 10, 2022 · Fundamentals

How to Build a Stackful C++ Coroutine from Scratch: Deep Dive into Context Switching

This article provides a step‑by‑step technical guide to implementing C++ stackful coroutines, covering the design of the owl.context API, low‑level context‑switch principles, register saving conventions on 32‑bit ARM, and complete source code for co_getcontext, co_setcontext, co_swapcontext and co_makecontext with illustrative examples and diagrams.

ARMAssemblySystem Programming
0 likes · 15 min read
How to Build a Stackful C++ Coroutine from Scratch: Deep Dive into Context Switching
Liangxu Linux
Liangxu Linux
Nov 21, 2021 · Fundamentals

Why Interrupts Matter: Unraveling CPU Interrupt Mechanisms and the IDT

This article explains how CPUs receive interrupt numbers through hardware, exceptions, or the INT instruction, describes the structure and purpose of the Interrupt Descriptor Table, and details the stack operations and control‑flow steps the processor performs to handle and return from an interrupt.

CPUException HandlingIDT
0 likes · 17 min read
Why Interrupts Matter: Unraveling CPU Interrupt Mechanisms and the IDT
21CTO
21CTO
Oct 27, 2021 · Fundamentals

Exploring Shrine: The God‑Inspired Fork of TempleOS and Its Unique Features

This article introduces Shrine, a community‑maintained fork of Terry Davis’s TempleOS, detailing its origins, unique specifications, HolyC language, added features like TCP/IP and a Lambda shell, and how to virtualize and explore this God‑inspired operating system.

HolyCOperating SystemShrine
0 likes · 6 min read
Exploring Shrine: The God‑Inspired Fork of TempleOS and Its Unique Features
NetEase Cloud Music Tech Team
NetEase Cloud Music Tech Team
Sep 26, 2021 · Fundamentals

How to Build a WebAssembly Interpreter: From Binary Decoding to Stack‑Based Execution

This article walks through the design and implementation of a WebAssembly interpreter, covering Wasm fundamentals, binary module structure, decoding into an in‑memory representation, stack‑based virtual machine execution, call‑stack management, and concrete code examples from the open‑source project.

Binary DecodingStackVMWasm
0 likes · 24 min read
How to Build a WebAssembly Interpreter: From Binary Decoding to Stack‑Based Execution
Liangxu Linux
Liangxu Linux
Sep 2, 2021 · Fundamentals

Understanding x86 Interrupts: Vectors, Descriptors, and Handling Mechanisms

This article explains the fundamentals of x86 interrupt handling, covering the distinction between interrupt vectors and descriptors, classification of internal and external interrupts, the role of the 8259A PIC, how interrupt numbers are assigned, and the mechanisms for saving and restoring CPU state during an interrupt.

CPUHardwareInterrupts
0 likes · 15 min read
Understanding x86 Interrupts: Vectors, Descriptors, and Handling Mechanisms
Sohu Tech Products
Sohu Tech Products
Jun 2, 2021 · Fundamentals

Low‑Level Atomic Operations (SE‑0282) – Swift Atomics Overview

This article presents a comprehensive translation of the Swift Evolution proposal SE‑0282, detailing the design and implementation of low‑level atomic operations, memory orderings, and related types such as UnsafeAtomic and UnsafeAtomicLazyReference, providing examples and discussing integration with Swift’s concurrency model.

Swiftatomic operationsconcurrency
0 likes · 57 min read
Low‑Level Atomic Operations (SE‑0282) – Swift Atomics Overview
Liangxu Linux
Liangxu Linux
Oct 31, 2020 · Fundamentals

How CPU Cache Works and How to Write Faster Code

Understanding CPU cache hierarchy, its speed advantages over memory, and the mechanics of cache lines, tags, and offsets reveals why code that maximizes cache hit rates—through sequential data access, branch prediction, and core affinity—can run dramatically faster on modern processors.

CPU cacheCache Hit RateMemory Hierarchy
0 likes · 18 min read
How CPU Cache Works and How to Write Faster Code
21CTO
21CTO
Jun 23, 2020 · Fundamentals

Will Traditional Embedded Engineers Disappear in the Age of High-Level Frameworks?

Since the early 2000s, embedded software engineers combined hardware expertise with low‑level C and assembly coding, but the shift to complex 32‑bit architectures, IoT demands, and high‑level development tools is eroding the need for deep hardware knowledge, prompting a debate over the future role of traditional embedded developers.

IoTembedded systemshardware abstraction
0 likes · 6 min read
Will Traditional Embedded Engineers Disappear in the Age of High-Level Frameworks?
ITPUB
ITPUB
May 16, 2020 · Fundamentals

Exploring Lei Jun’s Elegant 1994 Assembly TSR: RAMinit Source Code

This article presents the complete 1994 assembly source of Lei Jun’s RAMinit TSR program, explains its historical context, describes its hot‑key removal logic, interrupt hooking, environment backup and restoration, and details the low‑level XMS/EMS memory management routines.

AssemblyDoSTSR
0 likes · 27 min read
Exploring Lei Jun’s Elegant 1994 Assembly TSR: RAMinit Source Code
21CTO
21CTO
Mar 28, 2018 · Fundamentals

Unlocking Java Bytecode: How to Read, Decompile, and Rebuild Lost Source

This article explains why Java developers should understand bytecode, walks through JVM data types and stack architecture, demonstrates how to inspect compiled classes with javap, and shows practical examples of manual decompilation and reconstruction of source code using low‑level bytecode analysis.

JVMbytecodedecompilation
0 likes · 14 min read
Unlocking Java Bytecode: How to Read, Decompile, and Rebuild Lost Source