Tagged articles
Low-Level Programming
50 articles · Page 1 of 1
The article explains that classic FC (Famicom/NES) games like Super Mario Bros. and Contra were programmed in 6502 assembly language because the console's 8-bit MOS 6502 CPU, 2 KB RAM, and 40 KB ROM required low-level hardware control and extreme memory efficiency that high-level languages could not provide.
6502 CPUFamicomLow-Level Programming
0 likes · 5 min read

The article explains that FC (Famicom/NES) games like Super Mario and Contra were programmed in 6502 assembly language because the console's 6502 CPU, 2K RAM, and 40K ROM required low-level hardware control for performance and memory efficiency.
6502 CPUFamicomLow-Level Programming
0 likes · 4 min read

A handful of largely unknown engineers have written tiny, fast, deterministic and rigorously tested code—such as μC/OS, FreeRTOS, MQTT, SQLite and Linux kernel components—that has quietly powered everything from aircraft cockpits to household routers for decades without failure.
Industry HistoryLow-Level Programmingembedded systems
0 likes · 19 min read

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.
C++Low-Level ProgrammingMultithreading
0 likes · 30 min read

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 kernelLow-Level ProgrammingMultithreading
0 likes · 47 min read

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.
Low-Level ProgrammingPerformance Tuningc-programming
0 likes · 26 min read

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.
Low-Level Programmingalgorithm analysisbitwise-operators
0 likes · 12 min read

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.
Low-Level Programmingcompilationlinker
0 likes · 8 min read

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.
CPULow-Level ProgrammingPolling
0 likes · 7 min read

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.
Low-Level Programminghardware abstractionkernel-mode
0 likes · 5 min read

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 languageLow-Level ProgrammingSystems Programming
0 likes · 6 min read

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 HandlingLow-Level Programming__ex_table
0 likes · 21 min read

This article explains why mastering assembly language is crucial for understanding how computers execute code, covering the nature of low‑level languages, CPU instruction encoding, registers, memory models such as heap and stack, and walks through a complete x86 example with detailed instruction analysis.
CPUHeapLow-Level Programming
0 likes · 14 min read

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.
Low-Level Programmingassemblycomputer architecture
0 likes · 8 min read

This article introduces x86 assembly language, explaining its historical origins, the role of CPU registers such as EAX and ESP, the heap and downward‑growing stack memory models, and demonstrates basic stack‑frame operations like push, call, mov, add, pop, and ret through a simple compiled example.
CPULow-Level ProgrammingMemory
0 likes · 13 min read

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.
Low-Level ProgrammingMenuetOSassembly
0 likes · 6 min read

This article explains the fundamental roles of the instruction pointer and registers in CPU operation, covering their definitions, update mechanisms, assembly-level manipulations such as jumps, calls, returns, conditional branches, loops, and interrupt handling with clear code examples.
CPU architectureLow-Level ProgrammingRegisters
0 likes · 7 min read

This article explains Go's uintptr type, its definition, typical scenarios such as cgo interaction and system calls, provides Linux and Windows code examples, and highlights key differences from regular pointers to help developers use it safely and effectively.
GoLow-Level ProgrammingUnsafe
0 likes · 6 min read

This guide explains how to manipulate hardware registers, use function pointers, and perform bit‑level operations in C to control NAND Flash on S3C2410/S3C2440 platforms, providing concrete macro definitions, struct layouts, and initialization code for portable embedded development.
C++EmbeddedFunction Pointer
0 likes · 8 min read

The article explores how a developer generated billions of if‑statements in C to decide odd or even for 32‑bit numbers, scaling the approach with Python‑generated code, custom assembly, memory‑mapped binaries, and discusses the practical limits and performance of such an extreme solution.
C++Low-Level Programmingassembly
0 likes · 14 min read

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 languageLow-Level ProgrammingType System
0 likes · 18 min read

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.
Low-Level ProgrammingMemoryassembly
0 likes · 9 min read

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.
ConcurrencyJavaLow-Level Programming
0 likes · 9 min read

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.
CPULow-Level Programmingcomputer architecture
0 likes · 9 min read

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.
CPULow-Level Programmingcomputer architecture
0 likes · 6 min read

This book explores fundamental computer science concepts including programming language execution, compiler operations, memory allocation mechanisms, and system architecture through accessible explanations and practical examples.
Compiler designLow-Level ProgrammingTechnical Education
0 likes · 3 min read

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.
CPU architectureCPU registersLow-Level Programming
0 likes · 23 min read

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.
ConcurrencyJavaLow-Level Programming
0 likes · 11 min read

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.
8086Instruction SetLow-Level Programming
0 likes · 5 min read

This article explains x86 assembly direct and indirect memory addressing, the meaning of address length, how to use registers like BX for indexed access, and demonstrates loop‑based multiplication with detailed code examples and execution analysis.
LoopLow-Level Programmingaddressing
0 likes · 11 min read

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.
JavaLow-Level ProgrammingUnsafe
0 likes · 12 min read

This article explores Java's sun.misc.Unsafe class, detailing its construction, key capabilities such as low‑level memory management, object instantiation, class loading, CAS operations, and thread scheduling, while highlighting safety concerns and appropriate usage scenarios.
CASJavaLow-Level Programming
0 likes · 12 min read

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.
ARMC++Low-Level Programming
0 likes · 15 min read

This article explains the low‑level principles of C++ coroutine context switching, walks through the owl.context API design, demonstrates assembly implementations for co_getcontext, co_setcontext, co_swapcontext and co_makecontext, and provides practical examples and code to build stackful coroutines on 32‑bit ARM.
ARMC++Low-Level Programming
0 likes · 20 min read

This article delves into the eBPF virtual machine's architecture, detailing its register set, instruction classes, kernel helper invocation, and step‑by‑step analysis of sample bytecode that counts network packets, providing a solid foundation for advanced eBPF tooling.
LinuxLow-Level Programmingbytecode
0 likes · 11 min read

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


21CTOOct 27, 2021 · Fundamentals
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.
HolyCLow-Level ProgrammingShrine
0 likes · 6 min read

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 DecodingLow-Level ProgrammingStackVM
0 likes · 24 min read

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.
CPULow-Level Programminghardware
0 likes · 15 min read

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.
ConcurrencyLow-Level ProgrammingSWIFT
0 likes · 57 min read

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 RateLow-Level Programming
0 likes · 18 min read

This article explores advanced Linux kernel hooking techniques—including kprobe, jprobe, kretprobe, and livepatch—alongside lock mechanisms and atomic operations, providing code examples and practical guidance for safe and effective kernel instrumentation.
LocksLow-Level Programmingatomic-operations
0 likes · 10 min read


21CTOJun 23, 2020 · Fundamentals
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.
IoTLow-Level Programmingembedded systems
0 likes · 6 min read


ITPUBMay 16, 2020 · Fundamentals
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.
DoSLow-Level ProgrammingTSR
0 likes · 27 min read

The article recounts Xiaomi founder Lei Jun’s early passion for programming, showcases the full assembly source of his 22‑year‑old RI/TSR utility, and reflects on his enduring love for low‑level software development while illustrating the code with historic screenshots.
DoSLei JunLow-Level Programming
0 likes · 37 min read

This article explains the purpose and usage of key ARMv8-A registers—including general‑purpose, stack‑pointer, SIMD/floating‑point, program status, link, and program counter registers—while detailing their encoding, access modes, and relevance to exception levels.
ARMARMv8Low-Level Programming
0 likes · 10 min read

This article explains CPU registers, stack layout, function call conventions, and provides detailed explanations of how glibc implements memcpy and memset both in C and in low‑level assembly, including code snippets and the handling of remaining bytes.
Function CallLow-Level ProgrammingMemcpy
0 likes · 8 min read


21CTOMar 28, 2018 · Fundamentals
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.
JVMJavaLow-Level Programming
0 likes · 14 min read

This article introduces the fundamentals of x86 assembly language, explaining why low‑level code is needed, the history of assembly, CPU registers, the heap and stack memory models, and walks through a complete example with detailed explanations of each assembly instruction.
CPUInstruction SetLow-Level Programming
0 likes · 14 min read

This article walks through a basic C "Hello World" program, shows its compiled assembly in Visual Studio, and explains each instruction and register to reveal the low‑level operations hidden behind a seemingly trivial example.
C++Low-Level ProgrammingRegisters
0 likes · 7 min read
