Tagged articles
Systems Programming
58 articles · Page 1 of 1

21CTONov 3, 2026 · Artificial Intelligence
Gregory Kurtzer used OpenAI Codex and GPT-5.6 Sol with Human-Directed Agentic Engineering to create Ginux, a 139,000-line Rust kernel with full Linux ABI compatibility that boots Rocky Linux 10 in QEMU, demonstrating AI's potential for complex systems programming while highlighting ecosystem maintenance as the true moat.
AI-assisted programmingGPT-5.6Human-Directed Agentic Engineering
0 likes · 8 min read


21CTOOct 4, 2026 · Fundamentals
Zig 0.17.0 introduces a two-phase build system separating configuration and execution, a Build Server Protocol for editor integration, a self-hosted incremental ELF linker on x86_64-linux, and a thread-safe SafeAllocator cutting memory use by 50% and test time by 25%, alongside breaking language semantic changes like @bitCast redefinition.
ELF linkerSafeAllocatorSystems Programming
0 likes · 7 min read

This article traces how C's design — pointers, portability, and a minimal abstraction layer — made it the ideal language for OS kernels, from Unix's 1973 rewrite through Linux's adoption, cementing its dominance despite newer systems languages.
ANSI CC languageLinux
0 likes · 7 min read

The author compares Go, Rust, and Zig through hands-on experiments, revealing how each language embodies a distinct value system: Go prioritizes minimalism for team collaboration, Rust maximizes safety and performance via a dense type system, and Zig returns full control to programmers with manual memory management and data-oriented design.
GoRustSystems Programming
0 likes · 16 min read

Build Your Own X is a curated open‑source collection of over 200 step‑by‑step tutorials that guide you to rebuild core technologies—from operating systems to AI models—across 28+ categories, emphasizing that true understanding comes from recreating the wheel rather than merely consuming it, while warning about its size and dead links and advising a focused, single‑project approach.
Systems Programmingbuild-your-own-xlearning by building
0 likes · 20 min read

The April 2026 TIOBE index shows Rust, the youngest top‑20 language, slipping from a historic high of 13th to 16th, indicating a slowdown in its popularity despite strong performance, memory‑safety benefits, and growing adoption in system, AI, and open‑source projects.
AIProgramming Language TrendsRust
0 likes · 7 min read

This article explains how a C/C++ program is compiled into an ELF executable, details the ELF file structure, describes the kernel's validation and segment mapping, covers dynamic linking, and shows how the process starts execution from the _start entry point, providing practical commands and debugging tips.
DebuggingELFLinux
0 likes · 34 min read

The article shares a developer’s journey from initial frustration with Rust’s strict compiler to discovering its safety guarantees, performance advantages, and how its ownership model forces better architecture, illustrated with benchmarks, code flow diagrams, and practical takeaways for building reliable CLI tools.
CLI toolsRustSystems Programming
0 likes · 5 min read


21CTODec 13, 2025 · Fundamentals
At recent Linux kernel maintainer meetings, developers announced that Rust has shed its experimental label and become a permanent, core component of the Linux kernel, highlighting its growing maturity, production use, and the remaining challenges for full integration.
Linux kernelSystems Programmingmemory safety
0 likes · 4 min read


21CTONov 10, 2025 · Fundamentals
This article recounts the origins of the Zig programming language, detailing Andrew Kelley’s background, his motivations to overcome C’s limitations, and the personal experiences that drove him to design a fast, safe, and modern system‑level language.
Andrew KelleyProgramming LanguageSystems Programming
0 likes · 6 min read

After a 2015 breakup, programmer Andrew turned his frustration into Zig, a modern, safe, and efficient programming language that challenges C’s shortcomings, grew a vibrant community, secured funding through a nonprofit foundation, and now powers projects like Bun and TigerBeetle.
Compile-time ExecutionProgramming LanguageSystems Programming
0 likes · 8 min read

After a painful breakup in 2015, programmer Andrew Kelley channeled his frustration into creating Zig, a modern, safe, and efficient alternative to C, detailing its design goals, community growth, funding challenges, and the personal sacrifices behind its rise from a hobby project to a thriving open‑source language.
Programming LanguageSystems ProgrammingZig
0 likes · 9 min read

TBOX is an open‑source C library offering a unified, cross‑platform API that simplifies common development tasks across Windows, macOS, Linux, Android, iOS and BSD, featuring modules for streams, coroutines, memory, containers, algorithms, networking, databases, and more, with build instructions via xmake.
C++LibrarySystems Programming
0 likes · 12 min read

Linux kernel I/O mechanisms, from basic file operations and descriptors to advanced models like blocking, non‑blocking, multiplexed, signal‑driven, and asynchronous I/O, are explained in depth, covering their structures, system calls, caching strategies, and performance optimizations such as io_uring.
I/OLinuxSystems Programming
0 likes · 30 min read

This article examines the recent Go proposal to add a GOOS=none target, enabling Go programs to run on bare‑metal hardware without an operating system, outlines the TamaGo project's achievements, discusses compatibility challenges, and evaluates the potential impact on Go’s future development and use cases.
GoRuntimeSystems Programming
0 likes · 7 min read

From early 1970s Bell Labs' breakthrough of process isolation to the invention of in‑memory pipes, named pipes, and structured message queues, this article traces the evolution of inter‑process communication, highlighting design motivations, code structures, advantages, limitations, and the performance challenges that drove each innovation.
IPCProcess CommunicationSystems Programming
0 likes · 8 min read


21CTOMay 3, 2025 · Information Security
A Dutch consultancy’s experiment shows that Rust’s memory‑safety guarantees and rigorous testing can prevent critical DNS‑related vulnerabilities in billions of devices, delivering faster development and more reliable code compared to unsafe C implementations.
C languageSecuritySystems Programming
0 likes · 10 min read

This article explains why dynamic memory allocation is essential, models the heap as a parking lot, outlines the core challenges of implementing malloc and free, describes block headers, explores First Fit, Next Fit, and Best Fit strategies, and details splitting, internal fragmentation, and efficient coalescing using footers.
Systems Programmingallocation strategiesfragmentation
0 likes · 17 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

Explore Rust's powerful multithreading model, covering core concepts like ownership, channels, Mutex and Arc, with practical examples for web servers, game development, data processing, and scientific simulations, plus interactive quizzes to reinforce your understanding.
RustSystems Programming
0 likes · 9 min read

The author, a seasoned TypeScript developer, explains why they chose Rust over C/C++, outlines effective learning resources, and compares Rust’s compiler, type system, and memory management to JavaScript/TypeScript, highlighting the language’s performance, safety, and practical benefits for low‑level development.
CompilerRustSystems Programming
0 likes · 8 min read

This guide explains how Rust’s ownership model, zero‑cost abstractions, async/await, and built‑in safety features enable teams to build high‑performance, reliable backend services at scale, while sharing practical code examples and lessons learned from real‑world production deployments.
RustSystems Programmingperformance
0 likes · 13 min read

This guide explains the fundamentals of thread pools, how task scheduling works, and provides a step‑by‑step tutorial for building a custom, efficient thread‑pool implementation in Rust, complete with code examples and an exercise to test concurrent task execution.
Custom ExecutorRustSystems Programming
0 likes · 7 min read


21CTOSep 24, 2024 · Backend Development
At RustConf, Miguel Ojeda highlighted the challenges and optimism surrounding the Rust for Linux project, explaining how unstable Rust features, developer hesitancy, and industry interest shape the effort to make Rust a safe, second language for kernel development.
Linux kernelRustSystems Programming
0 likes · 5 min read

The 19th China Linux Kernel Developers Conference (CLK 2024) in Wuhan on October 26 invites paper submissions from September 10‑25 on topics such as RISC‑V, ARM64, scheduling, memory, storage, networking, containers, AI, automotive and embedded Linux kernel optimization, with abstracts limited to 500 words and results announced September 30.
Linux kernelOS developmentSystems Programming
0 likes · 4 min read

This guide shows how to add the bitflags crate to a Rust project, define a Permissions flag struct using the bitflags! macro, and perform common operations such as checking, inserting, and removing flags, while explaining the automatically derived traits and useful helper methods.
RustSystems Programmingbitflags
0 likes · 3 min read


21CTOAug 30, 2024 · Fundamentals
A recent Stack Overflow survey shows Zig developers earning the highest average salary of $103,000 in 2024, driven by its low‑level performance, scarcity, and growing demand for high‑performance system programming despite its modest community size.
Stack Overflow surveySystems ProgrammingZig
0 likes · 7 min read


21CTOJun 15, 2024 · Fundamentals
This article introduces the Virgil programming language, highlighting its goal as a lightweight high‑performance system language with powerful cross‑compilation, comparing it to Zig and Rust, and provides step‑by‑step installation, code examples, algebraic data types, and pointer usage for developers.
Cross-compilationSystems ProgrammingVirgil
0 likes · 8 min read

This article explains Go's unsafe package, covering its core concepts—Pointer, Sizeof, and Offsetof—provides practical code examples, outlines suitable scenarios such as system calls and performance tuning, and highlights the associated risks and best‑practice precautions.
GoMemorySystems Programming
0 likes · 5 min read

Rust, a modern systems programming language, offers memory safety without a garbage collector, a powerful ownership model, zero‑cost abstractions, robust error handling, and safe concurrency primitives, making it ideal for high‑performance, reliable software development, as demonstrated through detailed examples and explanations.
RustSystems Programmingmemory safety
0 likes · 8 min read


21CTOApr 8, 2024 · Fundamentals
This article explains how Rust’s built‑in language features—such as immutable defaults, ownership, borrowing, lifetimes, and compile‑time checks—provide memory safety that C, C++, and many managed languages lack, while also discussing the trade‑offs and ecosystem support.
Programming LanguageSystems Programmingmemory safety
0 likes · 10 min read

This article lists a comprehensive series of 46 video lectures covering essential Linux kernel concepts such as scheduling, memory management, synchronization, file systems, networking, and device drivers, providing a valuable resource for embedded and systems programmers.
Systems Programmingfundamentalskernel
0 likes · 6 min read

This article examines why C has long dominated operating‑system development, evaluates the advantages and limitations of using Go for OS kernels, and reviews concrete projects like the Biscuit OS that attempt to build a usable system with Go.
Biscuit OSGoSystems Programming
0 likes · 5 min read


21CTOJan 22, 2024 · Fundamentals
An extensive Rust developer roadmap breaks the learning journey into ten comprehensive sections—from introductory concepts and language basics to ownership, error handling, concurrency, modules, macros, traits, and the broader ecosystem—providing a structured guide for mastering Rust’s core features and libraries.
Programming LanguageRustSystems Programming
0 likes · 4 min read

When a computer has no active user tasks, the CPU appears idle but actually runs a special system idle process that repeatedly executes the privileged halt instruction, allowing the processor to enter low‑power states while the operating system manages process queues and scheduling.
CPUIdle ProcessProcess Management
0 likes · 8 min read


21CTOJun 27, 2023 · Fundamentals
The article explores how Rust's memory‑safety and efficiency are driving major companies like Microsoft, Google, and Amazon to rewrite operating‑system components and cloud services, while also tracing Rust’s quirky origins, rapid rise in popularity, and the challenges it still faces.
AndroidLinux kernelRust
0 likes · 10 min read

The article explains that many core components of modern computing—operating systems, network stacks, compilers, drivers, and runtimes—are written in C/C++, making the language essential for infrastructure, but because reinventing these complex systems is impractical, beginners often shift to higher‑level languages for application development, illustrated with a Lego analogy.
C++Systems Programmingprogramming fundamentals
0 likes · 4 min read


21CTOMar 5, 2023 · Backend Development
This article details the motivations, challenges, and outcomes of rewriting the KCL compiler from Python to Rust, highlighting significant performance gains, reduced bugs, memory savings, and the learning curve associated with adopting Rust for a large‑scale systems project.
CompilerKCLRust
0 likes · 10 min read

Cloudflare engineers have rewritten a core Nginx module in Rust, creating the Pingora proxy to replace Nginx, improve performance and safety, and pave the way for a future backend infrastructure without Nginx, highlighting Rust’s security benefits for complex, high‑scale services.
CloudflareProxyRust
0 likes · 4 min read

This article traces the evolution of the C programming language from its roots in ALGOL 60 through CPL, BCPL, and B, detailing how Ken Thompson and Dennis Ritchie created C, its standard versions, key features, advantages, disadvantages, and its lasting impact on modern software development.
C languageSystems Programminglanguage design
0 likes · 18 min read


21CTOOct 13, 2022 · Fundamentals
This article explores Rust's rise in systems programming, detailing its strengths such as safe concurrency, modern language design, and strong compiler feedback, while also highlighting challenges like a steep learning curve, complex async model, and low‑level memory management concerns.
ConcurrencyRustSystems Programming
0 likes · 10 min read

This article examines Rust's rapid rise, its safety‑focused design versus C/C++'s speed emphasis, real‑world adoption by major tech firms, and the ongoing debate about whether Rust can eventually supplant C and C++ for system‑level development.
ConcurrencySystems Programmingc++
0 likes · 9 min read

This article walks through the design, core data structures, and complete lifecycle of Workflow’s compact yet fully‑featured C thread‑pool (thrdpool), explaining its API, synchronization mechanisms, graceful shutdown strategy, and how tasks can be scheduled or even destroy the pool from within.
ConcurrencySystems ProgrammingWorkflow
0 likes · 19 min read


21CTOApr 2, 2022 · Fundamentals
The article explains how C has evolved from a programming language into a universal ABI protocol that every language must speak to interact with operating systems, detailing the challenges of FFI, ABI compatibility, and strategies for forward‑compatible API design.
ABIC languageFFI
0 likes · 20 min read

This article details a novel approach to overcoming CPython's Global Interpreter Lock by implementing a multi-interpreter architecture that isolates execution states, manages shared variables through thread-specific data, and introduces a subinterpreter pool to significantly enhance multi-core CPU utilization and algorithm execution performance.
CPythonConcurrencyGIL Optimization
0 likes · 15 min read

This article provides a deep technical walkthrough of libuv’s Linux implementation, covering epoll‑based I/O handling, level‑ and edge‑triggered events, the event‑loop architecture, timer management with a min‑heap, thread‑pool integration, and the mechanisms that drive asynchronous callbacks in Node.js.
EpollLinuxSystems Programming
0 likes · 34 min read


21CTOMar 24, 2021 · Fundamentals
The article examines how Rust is entering the Linux ecosystem, detailing discussions between Linus Torvalds and Greg Kroah‑Hartman, the motivations for using Rust in kernel development, and the potential impact on safety and driver programming.
Linux kernelRustSystems Programming
0 likes · 6 min read

Building your own operating system can feel daunting, but by navigating the cold‑start, early, middle, and later stages with carefully chosen books, hands‑on projects, and a minimalist tutorial, you can gain core OS concepts, avoid common pitfalls, and stay motivated throughout the journey.
Learning RoadmapOS developmentSystems Programming
0 likes · 14 min read

This article explains the architecture, core components, and operation flow of the Linux FUSE (Filesystem in Userspace) framework, details kernel module loading, mount parameters, request handling, and provides practical optimization tips for building efficient user‑space file systems.
FUSEFilesystem optimizationLinux kernel
0 likes · 20 min read

This article explains how a user‑level program becomes a Linux process, how the kernel views it through ELF loading, the role of the task_struct data structure, its key fields, task state transitions, and how the kernel stores the descriptor in memory.
LinuxProcess ManagementSystems Programming
0 likes · 10 min read

This article explains the four main I/O models—blocking, non‑blocking, I/O multiplexing (select/epoll), and asynchronous I/O—in the context of Linux network programming, clarifying their mechanisms, differences, and when each model is appropriate.
IO modelsLinuxSystems Programming
0 likes · 9 min read


21CTOOct 22, 2019 · Fundamentals
This article examines C's unmatched hardware efficiency, its safety trade‑offs, the rise of higher‑level languages focused on developer productivity, and why C remains essential for embedded, real‑time, and AI systems despite shifting popularity trends.
C languageSystems Programmingperformance
0 likes · 9 min read

This article traces the evolution of microkernel architecture from its origins in the UNIX family, explains the macrokernel versus microkernel design, details the three generations of microkernels such as Mach, L4, and seL4, and outlines their advantages, disadvantages, and examples like Fuchsia and Minix.
MicrokernelSystems Programmingkernel architecture
0 likes · 13 min read

This article revisits fundamental network I/O concepts, clarifying the differences between blocking, non‑blocking, synchronous, asynchronous, and multiplexed models through clear explanations and illustrative diagrams, helping developers build a solid mental model of how data moves between processes and the kernel.
I/O multiplexingSystems Programmingasynchronous
0 likes · 8 min read

This article explores C++’s origins, key language features, performance‑driven design, typical application domains, evolution over four decades, and why it remains essential for high‑performance systems, cloud infrastructure, and modern development despite its complexity.
C++Systems Programminglanguage design
0 likes · 11 min read

This article explains the Linux kernel’s widely used container_of macro, showing how it converts a member’s address into the containing structure’s base address through examples, typeof and offsetof usage, and demonstrates the underlying calculations with clear code snippets and illustrations.
C macroLinux kernelSystems Programming
0 likes · 5 min read

This article explains why the PingCAP team selected Rust over Go, C++, and Java for the TiKV storage layer, introduces Rust's core concepts such as ownership, borrowing, lifetimes, and thread safety, and shares practical tips, tooling, and lessons learned from real‑world Rust development.
RustSystems ProgrammingTiKV
0 likes · 19 min read

This comprehensive guide offers a step‑by‑step learning roadmap for new programmers, covering essential scripting languages, Unix/Linux tools, web fundamentals, advanced C/Java topics, databases, system programming, and practical projects to build solid technical foundations.
Learning RoadmapSystems Programmingbeginner guide
0 likes · 20 min read
