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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
