Tagged articles
low-level
16 articles · Page 1 of 1
This article gathers practical C‑language optimization techniques—ranging from integer declarations and branch reduction to loop unrolling and lookup‑table usage—to help developers improve execution speed and reduce memory consumption on resource‑constrained devices.
C++InlineLoop Unrolling
0 likes · 30 min read

The article explains how CPU pipelines, cache misses, branch‑prediction failures and lock contention cause non‑linear usage spikes, illustrates common pitfalls such as infinite loops, lock‑heavy spinning and catastrophic regex backtracking, and offers practical detection with perf and three rules—avoid busy‑waiting, use cache‑friendly layouts, and limit thread contention.
CPUConcurrencylow-level
0 likes · 6 min read

Most operating systems are written in C because its simple, portable syntax, minimal runtime, and direct memory and hardware access let developers write bare‑metal kernels that manage resources efficiently, making C the preferred high‑level language for system programming despite other languages being better for applications.
C languageSystem Programminghardware
0 likes · 5 min read

Bitwise operations manipulate binary digits directly, offering fast, low‑level computation for tasks such as arithmetic optimization, parity checks, power‑of‑two detection, swapping values, counting set bits, bitmasking, and hash table enhancements, with clear examples and Go code illustrations throughout the guide.
Algorithmbinarybitwise
0 likes · 7 min read

This guide presents the most commonly used ARM assembly instructions—including data processing, transfer, status register access, load/store, exception handling, and pseudo‑ops—explaining their syntax, purpose, and example usages for understanding Linux system startup.
ARMBootassembly
0 likes · 8 min read

This article explains the evolution of container runtimes, distinguishing low‑level and high‑level runtimes, introduces key projects such as runC, containerd, CRI‑O, and demonstrates practical demos and CRI integration with Kubernetes, providing code examples and architectural diagrams for cloud‑native practitioners.
CRIKubernetescontainer-runtime
0 likes · 16 min read

Hare is a newly announced system programming language by Drew DeVault that combines a static type system, manual memory management, and a minimal runtime to target operating systems, system tools, compilers, and other high‑performance low‑level tasks, with C‑like syntax but greater simplicity.
CompilerHareProgramming Language
0 likes · 5 min read

This article explains how an iOS/macOS application is launched, detailing the interaction between dyld and the Objective‑C runtime, the initialization steps performed by _objc_init, and the series of functions such as environ_init, static_init, map_images, read_images, and load_images that together realize classes, selectors, protocols and +load methods before main() is called.
Class LoadingObjective-C++Runtime
0 likes · 19 min read

The article explains the Linux kernel jump‑label mechanism, showing how it removes conditional branches by patching code at runtime, detailing the static‑branch logic, the __jump_table section, and providing a step‑by‑step C example with assembly illustrations.
jump-labellow-leveloptimization
0 likes · 5 min read


ITPUBFeb 27, 2021 · Fundamentals
This article demystifies the computer startup sequence by explaining why BIOS controls the initial steps, how memory‑mapping works, what the 0x7c00 boot sector is, and how the BIOS loads and transfers control to the operating system kernel.
BIOSassemblyboot process
0 likes · 18 min read

This article presents ten practical low‑level optimization strategies—ranging from reducing computational workload and extracting common subexpressions to loop unrolling, accumulator parallelism, and conditional‑move coding—each illustrated with C examples, detailed analysis, and before‑after performance comparisons.
C++Loopsassembly
0 likes · 18 min read

This article explains Java's Unsafe class, its low‑level memory operations, how Compare‑and‑Swap (CAS) is implemented via Unsafe, and how AtomicInteger leverages CAS for lock‑free thread safety while also covering the ABA problem and its mitigation.
CASConcurrencyJava
0 likes · 9 min read

WebAssembly, officially standardized by W3C in December 2019 as the fourth core web language, offers a secure, portable, high‑performance binary format that runs in browsers, enabling near‑native execution for tasks like audio, video, graphics, 3D, and AI, while introducing features such as threads, shared memory, and direct host object access.
WebAssemblybrowserlow-level
0 likes · 3 min read

The article explores how bitwise operations can dramatically speed up counting the number of set bits in a 32‑bit integer, presenting a naive O(n) solution and four successive optimizations that reduce runtime from about two seconds to under a tenth of a second, while sharing practical low‑level coding tricks.
C++bitwiselow-level
0 likes · 10 min read

Go’s syscall mechanism uses assembly‑implemented entry functions like Syscall and Syscall6 to invoke the kernel, while the runtime’s entersyscall and exitsyscall hooks notify the scheduler, allowing P resources to be released during blocking calls and handling privileged low‑level syscalls separately.
ConcurrencyGolow-level
0 likes · 17 min read

The article explains Java’s sun.misc.Unsafe class, detailing how to safely obtain its singleton instance, describing its low‑level memory, CAS, thread, class, and object operations, and outlining common high‑performance use cases while warning about the significant risks of misuse.
ConcurrencyJavaUnsafe
0 likes · 19 min read
