The Linux Programming Interface (TLPI) is the definitive guide to the Linux and UNIX programming interface—the interface employed by nearly every application that runs on a Linux or UNIX system.In this authoritative work, Linux programming expert Michael Kerrisk provides detailed descriptions of the system calls and library functions that you need in order to master the craft of system programming, and accompanies his explanations with clear, complete example programs.You'll find descriptions of over 500 system calls and library functions, and more than 200 example programs, 88 tables, and 115 diagrams. You'll learn how –Read and write files efficiently–Use signals, clocks, and timers–Create processes and execute programs–Write secure programs–Write multithreaded programs using POSIX threads–Build and use shared libraries–Perform interprocess communication using pipes, message queues, shared memory, and semaphores–Write network applications with the sockets APIWhile The Linux Programming Interface covers a wealth of Linux-specific features, including epoll, inotify, and the /proc file system, its emphasis on UNIX standards (POSIX.1-2001/SUSv3 and POSIX.1-2008/SUSv4) makes it equally valuable to programmers working on other UNIX platforms.The Linux Programming Interface is the most comprehensive single-volume work on the Linux and UNIX programming interface, and a book that's destined to become a new classic.
It took me more than a year to cover most of the chapters in this book but it is worth it. The most comprehensive explanation of computer science. The truly remarkable aspect is how easy it is to read. Bravo Mr. Kerrisk!
Great book. I'm halfway through and I learnt a lot of stuff and cleared my understanding of UNIX/Linux system programming. I've decided to read it to learn about real UNIX programming, system calls, how to implement socket servers, threading and processes in UNIX, signals and other low-level stuff. Although I am not a system UNIX programmer (I use Linux to run Java servers), it is very interesting to read and understand what layers of pretty cool (primarily in performance perspective) stuff are buried under the depths of abstractions JVM/Java and other languages, servers, libraries hide. Even something trivial like fopen/fread/fwrite are pretty complex and abstract from system calls point of view.
This is the one book to have for writing C programs for Linux. Goes into incredible depth on a variety of useful topics, and also discusses some Unix history along the way. If I had to have a gripe, it's that it's not twice as long to also discuss the kernel's internal mechanisms, although that's ably covered by other books.
This is the thickest, the heaviest and the most interesting reference manual that I've read from cover to cover. I'm genuinely surprised by high quality of "no-starch press" books
Everything you want to know about programming on Linux, from the system calls on up. This took me almost a year to get through, and it was worth it. I'll be revisiting this many times, I'm sure, for the bits on linking, terminals, and sockets, along with many other amazingly detailed chapters.
This book is very comprehensive and my favourite source of Unix lore. It's written for C programmers, but has useful diagrams and high-level stuff for anybody working with Unix systems.
This is a ***ing linux bible. Exactly what I need :) Interesting parts: Chpt 2. Fundamental concepts Chpt 8. Users and groups Chpt 9. Process credentials Chpt 17. Access control lists Chpt 18. Directories and links Chpt 27. Program execution Chpt 37. Daemons Chpt 38. Writing secure privileged programs Chpt 39. Capabilities Chpt 40. Login accounting Chpt 56-61. Sockets A. Tracing system calls B. Parsing command-line options C. Casting the NULL Pointer E. Further sources of information
An outstanding book; one of the classics. Extremely dense if read cover to cover, individual sections are highly readable; this is a great book to have both at your desk for reference or at your toilet or bedside for quick reads.
This book is the definitive work companion for every developer. It is an excellent tour through all the features that Linux provides, not limited to processes, networking, I/O, inter-process communication, etc. There's always something to learn from this book.
Understanding Linux syscalls is important for developers. Many innovations were made possible due to changes or the appearance of new system calls. And when your application doesn't operate with the expected performance, understanding the Linux system calls will go a long way to help you understand the bottleneck. I read a lot recently about eBPF, and this book was helpful to feel comfortable on this advanced, also important, topic.
With over 1500 pages, this book will test the solidity of your bookshelf, and your desire to discover the Linux APIs. It's best to lay the book on your desk. You will not read the book in a few days, but you don't need to read the whole book. It contains many chapters, many examples in C, and reading the first pages of every chapter can be enough to decide if you want to learn more on this subject. You can always come back to read the code examples more attentively before using them in your programs.
The Linux Programming Interface is truly a masterpiece. Few technical books impressed me so much (and I read a lot!). The explanations are always clear, succinct, and the book is perfectly organized. A book like this requires dedication over numerous years before going to press. Michael Kerrisk is the maintainer of the Linux man-pages project since 2004, and many man pages were edited during the preparation of this authoritative book. I cannot stop seeing his name now that I have completed the book.
The Linux Programming Interface is an excellent resource for anyone looking to deepen their understanding of both the Linux API and C programming. Although the book is somewhat old, the majority of its content remains highly relevant and practical.
I did choose to skip a few chapters—namely Chapters 15 (File Attributes), 17 (Extended Attributes), 18 (Directories and Links), 39 (Capabilities), and 40 (Login Accounting)—because I felt that the material in these sections was either deprecated or no longer particularly useful. I also bypassed the System V–related parts of the text since they focus on a proprietary system, and I didn’t find them essential for my learning objectives.
Despite these skipped sections, the rest of the book thoroughly covers crucial topics such as multithreading, multiprocessing, inter-process communication, and memory management. I especially appreciated the abundance of exercises, which provided great hands-on experience with both C programming and the Linux API.
Overall, I highly recommend The Linux Programming Interface to anyone interested in developing a strong foundation in Linux system programming. Even though some parts may feel dated, the core material is still incredibly valuable. https://github.com/yusufatalay/linux_...
This is an absolutely stellar compilation of knowledge, combining the reusable utility of a reference with historical justification for the idiosyncrasies of various UNIX systems today.
This helped close the loop on a lot of fundamental concepts that I had learned ad hoc through experience but had never "read the manual" on, and as a result clarified a lot of my understanding.
I was able to grok this with a limited knowledge of C (I learned it in university, but never used it professionally). Kerrisk does an excellent job of walking you through the concepts despite such knowledge however. The example C programs add additional clarity.
If you do any sort of development work on UNIX systems, this book is a must if you want to really understand what is going on. I now feel much more comfortable diving into code for tools like SSH or Bash, where in the past these would have been relatively inaccessible given the conceptual understanding I was lacking.
The most complete programming interface book for any operating system today. A must have for any serious system designer, programmer and Linux/Unix/BSD enthusiast. Contains a chuck full of exercises to solidify one's understanding. I would also say that this text has the best organization of subjects I have seen in a computer science book. Buy it now. Now!
This book is really comprehensive. Hence, it's size. Nonetheless, it manages to be really good because of how straight-to-the-point it is and, more importantly, the code examples provided.
This book is a reference material but it is also a guide that explains how UNIX works. It's arguably the best I've seen on the market.
Non lo ho letto dall'inizio alla fine, lo uso prevalentemente come guida di riferimento. É il miglior libro di programmazione che conosca: esaustivo e allo stesso tempo conciso, chiaro e scorrevole. L'autore ha realizzato un'opera eccezionale.
Great book with so much to learn. Because of the time that it would take I could not try everything described in the book but that not the problem of the book. Maybe the book would be better to when there are more real-life examples added. And some more info regarding the *BSD systems.
Very good intro into the large arrays of system calls that make Linux such a wonderful OS. Give it a read if you are interested in making applications that can run on the Linux kernel.
I would say confidently, that's one of the most greatest books of computer science every, not only it explains Linux thoroughly but also the principles of Operating Systems and CS in general, well organized and can be useful as a reference to developing systems software, and to deepen someone's understanding of Operating systems, Linux, CS. Incredible work by Michael Kerrisk