A developer recreated a 1970s PDP‑11 environment, wrote a single‑layer, single‑head Transformer in assembly, and trained it on a sequence‑reversal task, achieving 100% accuracy after about 350 steps and a total training time of roughly 5.5 minutes.
The article examines famous game creators, ultimately arguing that Scottish programmer Chris Sawyer stands out as the greatest thanks to his solo development of RollerCoaster Tycoon using mostly x86 assembly, which delivered massive sales, technical brilliance, and lasting influence.
This article explains how system calls differ from regular function calls, demonstrates a simple x86_64 hello‑world program that uses the syscall instruction, and details how Linux maps syscall numbers to kernel functions via the MSR LSTAR register.
While both while(1) and for(;;) create infinite loops in C, this article explains their syntax, execution flow, and demonstrates through compiled assembly that, despite subtle differences, they generate identical machine code, helping developers understand any performance or size implications.
The article explains the common misconception that address 0 is always illegal, clarifies why operating systems reserve it, and shows how bare‑metal and embedded development can freely use address 0 with concrete assembly examples and C/C++ representations.
Microsoft has finally released the source code of its 1976 6502 BASIC interpreter under an open‑source license, a historic move that revives the early programming language that ran on Apple II, Atari 2600, NES and Commodore 8‑bit machines, and invites enthusiasts to explore and rebuild the original environment.
In the 1950s programmers wrote directly to hardware, but the fragility of hard‑coded memory and I/O led to the invention of a privileged “expert” kernel mode and a restricted “novice” user mode, with a special instruction to switch, forming the basis of modern system calls and operating system protection.
The article explains how operating‑system multitasking and process switching share the same underlying mechanism as function calls, demonstrates a C program that overwrites a return address to jump to an unexpected function, and shows the resulting assembly to illustrate the similarity between buffer‑overflow attacks and legitimate context switches.
This article examines SIMD (Single Instruction Multiple Data) technology, its relevance to Go’s performance goals, the challenges of integrating SIMD into Go’s design, current standard‑library limitations, third‑party libraries, compiler support, and practical assembly examples, concluding with prospects for future Go SIMD adoption.
The article explains the essence of process switching by comparing it to function calls, demonstrates how manipulating a function's return address can redirect execution to another function, and shows the underlying assembly and security implications of such control‑flow changes.
This article provides a comprehensive overview of the Linux ptrace system call, explaining its role in process debugging, detailing request parameters, demonstrating practical C examples for tracing system calls, single‑stepping, setting breakpoints, and exploring how DWARF debugging information links source code to executable addresses.
This guide provides a thorough introduction to x86 assembly language, covering GNU syntax, CPU architecture, registers, instruction formats, data types, memory models, and practical examples with NASM and GNU as, enabling readers to write efficient low‑level code and deepen their understanding of computer systems.
Ant Financial's MorseCrypto team secured first place in the 2024 Financial Cipher Cup second‑stage competition by delivering highly optimized SM2, SM3, and SM4 implementations on X86 and ARM platforms that achieve up to 4.3‑times faster verification while meeting strict security and memory constraints.
This article traces how simple binary switches evolved into CPUs, machine code, assembly language, control‑flow constructs, recursion, syntax trees, and finally modern compilers that translate human‑readable code into executable instructions.
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.
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.
This article provides a comprehensive overview of how Linux kernel system calls are implemented on the x86-64 architecture, covering the conceptual differences from regular function calls, register conventions, initialization processes, syscall tables, and practical assembly examples such as write and getpid.
The article explains how the primitive binary switches of early CPUs evolved through machine code and assembly into high‑level languages, using recursion, syntax trees and compiler concepts to bridge human abstraction with the CPU's concrete operations.
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.
The article analyzes a crash that occurs on Windows 10 when a 64‑bit program mixes RSP and ESP instructions, explains how writing to the 32‑bit ESP register zero‑extends the upper 32 bits of RSP, and shows how this stack‑pointer mismatch leads to an access‑violation error that does not appear on Windows 7.
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.
The article explains how encapsulating peripheral registers in a struct rather than using separate global variables reduces literal‑pool usage, cuts instruction count, and improves execution speed on Cortex‑A9, providing step‑by‑step assembly analysis, compilation commands, and further optimization techniques.
The article investigates undocumented x86 opcodes, describing a depth‑first search that uses page‑faults to locate hidden instruction boundaries, and reports finding dozens of executable but undocumented instructions on Intel and AMD CPUs, highlighting potential security risks and the need for vigilant hardware analysis.
The article explores how Nordic programmers like Linus Torvalds, Andreas Kling, and Ville Turjanmaa have built full operating systems—from Linux to SerenityOS and the assembly‑only MenuetOS—highlighting their motivations, technical achievements, performance gains, and the cultural environment that fuels such ambitious open‑source projects.
This article systematically analyzes a function call in an embedded system from four perspectives—assembly code, registers, stack layout, and map files—illustrating how the compiler generates the call, what values each register holds, how the stack is allocated, and how to trace execution using disassembly and memory views.
This article explains how integrating Go with assembly language can overcome Go's performance and low‑level control limits for system and driver development, covering basic concepts, integration methods, multi‑CPU architecture support, practical code examples, and the resulting performance and portability benefits.
This article explains how Go leverages the Plan 9 assembly language as an intermediate representation, covering its history, portability benefits, performance advantages, cross‑platform challenges, and provides a step‑by‑step example of writing, compiling, and running a simple assembly‑backed Go program.
This article explains how Linux system calls serve as the primary interface between user‑space programs and the kernel, describes the transition from user mode to kernel mode, and provides step‑by‑step debugging examples and source‑code snippets for x86_64 architectures.
The article explains how AArch64 stack unwinding works using both frame‑pointer based methods and DWARF .eh_frame/.debug_frame CFI data, detailing the calling convention, compiler effects, CIE/FDE structures, and their integration into Android’s simpleperf profiler for accurate back‑traces.
A segmentation fault in a simple tile‑index copy loop was traced to GCC 9.2’s -O3 loop‑vectorization pass miscalculating structure offsets, and the issue was resolved by disabling -ftree-loop-vectorize or upgrading the compiler, as newer GCC versions and Clang handle the code correctly.
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.
This article explains the Linux kernel boot sequence, covering the decompression of a compressed kernel, the early startup code in head.S, the preparation steps performed by U-Boot, and the detailed initialization phases—including architecture setup, memory management, process creation, and the start_kernel routine.
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.
A client‑reported segmentation fault was traced to changing GCC’s optimization level from -O2 to -O3, revealing a bug in the -ftree-loop-vectorize option that miscalculates struct sizes, and the article explains the analysis, assembly inspection, NEON details, and a practical workaround.
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.
By reverse‑engineering the iOS 16 WKWebView image‑analysis crash, the team identified a nil‑buffer bug in VisionKitCore’s CGImage creation, then mitigated it by runtime‑hooking VKCRemoveBackgroundResult’s createCGImage (returning NULL) and suppressing the image‑analysis gesture, reducing crashes from thousands to near zero.
The article explains how C++ value categories—lvalue, prvalue, and xvalue—govern function return handling, parameter passing, and object lifetimes, detailing hidden out‑parameters, copy‑elision, const‑reference lifetime extension, rvalue references, and the role of std::move in enabling move semantics.
An Ant Group engineer reverse‑engineered a severe iOS 16 keyboard crash affecting the Alipay app, traced it to a faulty lock in UIKeyboardTaskQueue, and implemented an assembly‑level patch that eliminated the bug across millions of devices.
This article details how a hidden memory‑management bug in iOS 16’s keyboard component caused massive crashes in the Alipay app, explains the reverse‑engineering process that identified the faulty UIKeyboardTaskQueue logic, and describes the assembly‑level patch that eliminated the issue across millions of devices.
Android’s Shadow Call Stack (SCS), silently enabled since Android R on AArch64 devices, stores return addresses in a protected register‑based stack separate from the regular stack, complementing stack canaries and requiring hardware support, while developers can activate it via -fsanitize=shadow-call-stack and avoid using X18 elsewhere.
This quick‑start guide walks readers through ARM assembly development by teaching simple template functions, exposing typical parameter‑passing and register bugs with debugging tricks, and demonstrating a depthwise convolution written in assembly that delivers roughly 4.7× faster inference on a Huawei Mate40 Pro compared to its C++ counterpart, while also covering ARM32/ARM64 register conventions, vector instructions, and floating‑point handling.
This article explains the syntax and execution semantics of while(1) and for(;;) in C, compares their generated assembly code, and demonstrates through a practical gcc compilation that both constructs produce identical machine code for an infinite loop.
While(1) and for(;;) both create infinite loops in C, but this article explains their syntactic forms, execution semantics, and demonstrates through compiled assembly that they generate identical machine code, highlighting subtle differences and confirming they are functionally equivalent.
This article explains how to accurately measure the execution time of Objective‑C methods on iOS by implementing a custom objc_msgSend hook in ARM64 assembly, replacing the original implementation with fishhook, and visualizing the results using Chrome tracing, offering a low‑cost, non‑intrusive performance profiling solution.
This article provides an in‑depth guide to analyzing Android native crashes, explaining common SIGSEGV types, interpreting tombstone logs, extracting register and memory information, using coredumps, and employing tools such as GDB, lldb, ASAN, HWASAN, and assembly inspection to trace and resolve crash causes.
This article explains the Linux boot sequence on x86 hardware, covering BIOS ROM loading, real‑mode memory layout, the MBR, the setup() assembly routine, transition to protected mode, and the startup_32() function that prepares paging before the kernel begins execution.
This comprehensive guide explores the fundamentals of embedded real‑time operating systems, covering instruction set architecture, hardware‑software ecosystems, multi‑task scheduling algorithms, inter‑process communication primitives, software timers, and concrete RISC‑V and Cortex‑M porting implementations with Rust and assembly examples.
MegPeak is an open‑source processor debugging tool that evaluates instruction peak bandwidth, latency, and memory bandwidth, enabling developers to benchmark CPUs, plot Roofline models, and guide low‑level algorithm and kernel optimizations for AI workloads.
The article demonstrates three advanced Go techniques—eliminating the standard runtime by custom entry points, building a simple Python JIT compiler that translates bytecode to optimized machine code, and bootstrapping the Go compiler itself via AST‑to‑LLVM translation—offering practical code examples that reveal compiler internals.
This article explores why the naïve (a + b) / 2 formula overflows for 32‑bit unsigned integers and presents several safe techniques—including subtraction‑first, bitwise‑based, wide‑type casting, and carry‑rotate instructions—complete with C++ code and assembly examples.
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.
This article clarifies three frequent misunderstandings about iOS15+ dynamic linking—namely the encoding of b/bl instructions, the need for rebase/bind in __TEXT segments, and the mismatch between Mach‑O segment VM size and file size—by explaining the underlying ARM64 architecture, PIC concepts, and providing concrete dyld tool examples.
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.
This article explains how function calls are implemented using a stack‑based memory model, describing stack frames, the role of base and stack pointer registers, and the assembly instructions that create and dismantle these frames during program execution.
This article presents a backend‑focused study on reducing latency of vector‑based ad recommendation retrieval by leveraging Gonum, SIMD AVX2 intrinsics, and direct Plan9 assembly integration in Go, and it validates the approach with detailed performance benchmarks and CPU usage analysis.
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.
The article explains the syntax and semantics of while(1) and for(;;) infinite loops in C, compares their generated assembly code, and demonstrates through compiled examples that both constructs produce essentially identical machine code despite minor semantic differences.
This article explains the syntax, execution flow, and practical differences between the C constructs while(1) and for(;;), demonstrating through compiled assembly that both produce identical code for an empty infinite loop under typical compiler settings.
This article explains the syntax and semantics of C's while(1) and for(;;) constructs, compares their execution flow, shows how to compile each to assembly with gcc, and demonstrates that, aside from file names, the generated code is identical under typical settings.
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.
This article explains what program core dumps are, how to interpret core‑dump files, and provides detailed GDB debugging techniques—including register inspection, stack frame analysis, variable printing, memory dumping, and handling optimized code—to locate and resolve the root causes of crashes.
Benchmarking C++ exceptions against error‑code handling reveals that frequent throws incur more than tenfold slowdown due to libc++ runtime functions like __cxa_allocate_exception and stack unwinding, while rare exceptions and empty try blocks add negligible overhead, highlighting the trade‑off between safety and performance.
The article walks through Go’s memory allocator by first demonstrating assembly‑level debugging with Delve, then detailing its TCMalloc‑inspired design where tiny, small, and large objects follow distinct paths through per‑P caches, central spans, and the global heap, highlighting the roles of mcache, mcentral, mspan, and mheap.
The article traces the evolution from primitive CPU operations expressed as binary switches, through the birth of assembly language and low‑level patterns, to the abstraction of recursion, syntax trees, and compilers that translate human‑readable code into machine instructions.
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.
This article explains the internal workings of Golang v1.0 coroutines, covering their creation, stack‑switching logic, scheduler design, virtual‑memory basics, assembly examples, channel handling, socket event loops, and the low‑level implementation of defer, panic, and recover.
This article explains the concept of per‑CPU variables in the Linux kernel, how they are defined with DEFINE_PER_CPU, linked into the .data..percpu section, initialized during boot, and accessed at runtime via the GS register and macro expansions such as this_cpu_read_stable.
The article discusses three approaches to binding experimental components, critiques their limitations, and proposes a reusable slot‑card model implemented in TypeScript, complete with base classes, Card, Slot, and Engine code to manage assembly and updates.
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.
The article compares the infinite loop constructs for(;;) and while(1) in C by compiling simple programs, examining the generated assembly with gcc, and shows that both produce identical machine code, while also noting compiler warnings and style preferences.
This article presents a comprehensive guide on migrating business code from x86 to TaiShan aarch64 servers, covering language differences, compilation toolchains, architecture‑specific issues such as compiler options, assembly rewrites, memory ordering, floating‑point behavior, and recommended GCC optimizations.
This article demystifies the computer startup sequence by explaining why BIOS controls the first steps, how memory‑mapping works, how the CPU’s PC register is forced to 0xFFFF0, how the boot sector is loaded to 0x7C00, and what the initial assembly code actually does.
This article demystifies the computer startup sequence by explaining why BIOS controls the initial boot, how memory mapping and real-mode address space work, the role of the 0x7C00 loading address, and what the boot sector code actually does.
This article explains how Linux implements system calls via software interrupts, fast syscall/sysenter instructions, and the virtual dynamic shared object (vDSO), comparing their performance to regular function calls and showing concrete code examples and step‑by‑step execution details.
This article explains why adding parameter‑reading code to a variadic‑function hook causes a deterministic crash due to stack context pollution, analyzes the calling‑stack layout and register usage with ARM64 assembly, and presents a heap‑based context‑saving solution using TrampolineHook to safely intercept variadic methods on iOS.
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.
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.
This article presents the complete assembly source of the RAMinit TSR program written by Lei in 1994, explains its purpose as a hot‑key‑driven memory‑management utility for DOS, describes its interrupt‑vector handling, memory‑copy routines, and includes detailed comments that reveal the inner workings of this historic piece of system software.
This article explains what an IDT is, how it is initialized, the structure of interrupt descriptor entries and gates, the implementation of traditional system calls via int 0x80, and the setup and handling of hardware interrupts in the Linux kernel.
This article explains how to use SSE2 SIMD instructions to optimize string replacement operations, demonstrating a 16-character batch processing technique that significantly improves performance for longer strings.
This article examines how the Go compiler translates range loops into low‑level assembly instructions, walks through a concrete example with code and assembly output, explains each instruction’s role, and highlights recent compiler improvements that enhance safety and scheduler interaction.
A comprehensive guide that walks you through the inner workings of a computer—from the CPU’s fetch‑decode‑execute cycle and register set, through memory hierarchy and binary arithmetic, to function calls, assembly language, and essential operating‑system concepts like APIs, multitasking and virtual memory.
Explore the essential building blocks of modern computing, covering CPU architecture, memory hierarchy, binary operations, compression techniques, operating system fundamentals, and assembly language, with clear explanations, diagrams, and code examples that demystify how hardware and software interact at the lowest level.
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.
This article explains how classic NES titles like Super Mario manage to fit all code, graphics, music and level data within a mere 128 KB by exploiting 2‑bit palettes, minimalist MIDI audio, tile reuse and hand‑crafted assembly, revealing a storage gap of five to seven orders of magnitude compared to modern games.
This article shares a detailed experience of migrating business code—including C/C++ and Java applications—from x86 servers to TaiShan aarch64 servers, covering language differences, compilation issues, assembly rewrites, compiler options, and performance optimizations to achieve smoother execution on the new architecture.
The article explains Go slices as three‑field descriptors pointing to an underlying array, details creation methods, shows the low‑level runtime representation and assembly for make, describes how append triggers growslice with capacity‑doubling or ~25 % growth and alignment, and clarifies sharing, nil slices, and passing semantics.
This article explains three ways to perform Linux system calls—using glibc wrapper functions, the low‑level syscall interface, and inline assembly with the int 0x80 instruction—illustrating each method with a chmod example, error handling, and code snippets.
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.
This article explains how the Linux init process (pid 1) transitions from kernel mode to user mode, detailing the role of kernel_thread, run_init_process, kernel_execve, the int 0x80 system call, register changes, and a practical experiment confirming the __USER_CS value.
This article explains how to locate the Linux 2.2.5 i386 kernel source, describes the bootloader (bootsect-loader) and its related files, and walks through both real‑mode and protected‑mode initialization steps, including parameter tables and memory layout, to help readers understand the OS startup process.
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.
