Linux Programming Interface

About the book

The Linux Programming Interface is a large technical reference on how programs talk to the Linux kernel. Michael Kerrisk, long associated with the Linux man-pages project, organizes the material around the system call interface: the functions and conventions a user-space program uses to request file operations, processes, signals, memory, sockets and other kernel services. The book sits between a manual and a course, explaining what each interface does and why it behaves as it does.

Its scope is broad by design. It covers the POSIX and Linux-specific APIs that working systems programmers encounter, and it treats portability and standards conformance as recurring concerns. The writing leans on small example programs and worked explanations, so a reader can follow a call from its declaration through its error cases and its interaction with kernel state. That structure rewards sequential reading and supports targeted consultation.

The book assumes familiarity with C and with basic Unix concepts. It is not an introduction to programming, and it does not try to be a kernel internals text, though it explains enough kernel behavior to make the interface intelligible. Treat it as a durable desk reference for the Linux API layer.

How to read it

Approach it as a reference with a spine. Read the early chapters on files, processes and signals in order, because later material assumes that vocabulary. After that, jump to the chapters relevant to your work and keep the index close. The examples are meant to be compiled and run, and the explanations make more sense when you follow the code.

Expect density. Kerrisk writes carefully and at length, with attention to edge cases, error returns and differences between Linux and other Unix systems. That thoroughness is the point, but it makes the book slow going in long sittings. Set a specific question before each session and stop when it is answered. The prose is plain and the organization is predictable, which helps.

Who it suits

Systems programmers, students of operating systems and developers who need to understand POSIX and Linux APIs beyond what a quick manual page provides will get the most from it. It suits readers who already write C and want a reliable account of how calls behave, including their failure modes. Engineers moving from another platform to Linux will find the portability discussion useful.

Reading considerations

The book is long and detailed, and it is a reference rather than a tutorial, so readers without C or Unix experience will struggle. Linux interfaces evolve; check current manual pages for behavior that may have changed, and confirm which edition you have before relying on a specific detail.