Bubble Witch Saga 3 Industrial Deals HPC Best Books of the Month Red Shoes We Love nav_sap_plcc_ascpsc August Greene All-New Fire 7, starting at $49.99 Starting at $39.99 Grocery Handmade Gift Shop Home and Garden Book a house cleaner for 2 or more hours on Amazon victoriaS2 victoriaS2 victoriaS2  Three new members of the Echo family Introducing All-New Fire HD 10 with Alexa hands-free $149.99 Kindle Paperwhite GNO Shop now TG18SW_gno

on May 30, 2013
Since 2006 there have only been a few books published on Linux programming, an area that was quite lively until 2002. It wasn't until this time that authors started admitting that C++ was of any importance in Linux design. Ok, the kernel and all the drivers are written in C. This makes sense, but applications need a language with object oriented organization to defeat the enormous level of complexity that modern applications need to manage. Published in 2008, this version expands on the same subjects covered in the 2004 version.

"GNU/Linux Application Programming" expands on the APIs that the application must use to interface to the file system, memory, networking, and system management. There is some coverage of IPC ( shared memory, message queues, and pipes ) programming to link applications behind the scenes as well. The coverage of POSIX threading, semaphores and mutexes is robust. System calls are very limited, that will require another reference if you want that covered in depth.

So, if you want to extend your Linux programming abilities and build rock solid professional applications, just buy and read the book. You will find the subjects well explained and I am glad to have this book in my programming library. Keep in mind that current supply is limited and that Amazon is not showing any newer Linux programming books to be published through 2014.
0Comment|Was this review helpful to you? Report abuse
on June 9, 2007
I've been programming for a good while but I am relatively new to Linux. Sure I've flirted with it a little in the past but I've mostly been down in the worlds of Nulceus, vxworks, and threadx.

I found myself needing to come up to speed fast on a lot of little things - multi threading, communications, piping and build processes. This book covers it all in good enough detail to get you on your feet fast. The sections on signals was especially helpful as was the nice overview of gdb which while not the debugger type I'm used to - really proved to me how useful that old program still is (and since I'm stuck with the command line version of it - how to really make that version sing).

As a quick reference/introduction this book can't be beat. Highly recommended
0Comment| One person found this helpful. Was this review helpful to you? Report abuse
on November 23, 2014
Perhaps this is good for beginner as a reference. I expected some reasons underlying the design of the APIs, such as those helping to make choices between different APIs and reason about performance issues etc. But there isn't much beyond simple online tutorials about building "Hello World!" on Linux and API documentation.It is not something you would read from end to end to gain some wisdom, i.e. learn the "why"s. But look at find the basic API usage once the API selection (e.g. TCP vs. UDP) has been made.
0Comment|Was this review helpful to you? Report abuse
on November 8, 2010
I am an experienced software engineer but have not had much experience programming for Unix/Linux environment. I was also interested in a basic book to go into low-level C system APIs. This book provided a good introduction for me at a reasonable pace over a wide range of subjects. I focused on the C programming chapters, but there are additional chapters for things like source control, shell commands, awk, sed, Ruby, Python and debugging.

Book expects some familiarity or background with C programming language. While basic functions of the Standard C library are described, the language constructs and syntax of C are not referred to at all but are assumed familiar to the reader.

Other reviewers have mentioned that source code was available for free online so CD was not valuable. I have not found this to be the case, so in that respect the CD is useful.

Some negatives, in general code samples were often incomplete, with errors. Several of the chapters of the book contain content with mistakes or do not list all necessary prerequisites. For example, I tried to perform almost every code/script sample provided and ran into numerous issues or additional packages and tools to install that were never mentioned. Some code would execute on a 32-bit Linux system but not on a 64-bit system. Also I found the code samples provided on the CD to be lacking in completeness, for example a sample code for a Makefile example from chapter 6 did not include the source files the Make script was supposed to build. In the end it did encourage me to create my own "Hello World" type source files just to go through the same steps being described in the book. Other chapters included source but not Makefiles to compile the code, source files with no relation to the examples in the book and source files that did not compile. Generally such errors could be resolved with a few minutes of Internet research on the errors/warnings.
0Comment| 2 people found this helpful. Was this review helpful to you? Report abuse
on March 4, 2005
This book fits into an interesting and often neglected spot between the operating system (Linux) and the programming language (C). There are lots of books on both C and Linux. This one ties the two areas together.

The C language is a general language with applications on many operating systems. Linux, of course is one operating system that can use C. Inbetween the two lie the areas of taking the raw language and turning the code into an application that can actually be of use to someone.

Contained within the GNU/Linux system are many software packages to establish the programming environment. There's the compiler and operating system. But more than that are systems to optimize the resulting code, to combine the program you wrote with other standardized routines from the system. These other utility programs have names like gcov, gprof, automake and so on. To the newcommer to GNU/Linux, there is a bewildering array of names (that only kind of make sense) for programs that ease your development task.

In addition there's discussion on various programming concepts such as the Linux file system, programming threads, piped, sockets and so on. Again, these are areas that are part of the standard GNU/Linux system but which are discussed here in ways to make them useful to the applications developer.

This is a carefully positioned book that will be of great help to the beginning developer.
0Comment| 18 people found this helpful. Was this review helpful to you? Report abuse
on April 17, 2011
This book fulfills its main purpose, of teaching the basics about linux programming. I was between this book (GLAP) and the 4th edition of Beginning Linux Programming (BLP). I chose this one because I found out that it is more direct to the point, while the BLP is more detailed. Once I didn't expect to become a Linux expert with any of these books, I chose the one with the more direct approach.

I would like a quick overview of the various aspects of Linux programming, a straightforward book which could teach Linux basics in few months. So this book made it. I also checked this site [...] for a description of this books, so it helped me in my choice.

Things I enjoyed about this book:
- the book approach is direct, it doesn't locks itself discussing every single detail (such kind of details are left to specialized books, or bibles like "The Linux Programming Interface");
- the emulation chapter was something very usefull, I wonder why the BLP doesn't even mention emulation.
- the book's layout is simple and clear, without fancy things.
- the writing style is loose and easy to follow, it is not a dense and heavy reading. Short paragraphs, short chapters, short examples, all this make the reading enjoyable and don't required a high amount of focus to understand. Some books are too dense that you have to read over and over again the same sentence to catch the author's intent. Here is different, you read and understand, no big issue.

Things the author could improve:
- the biggest issue I found in this book were the typos in the listings. Things like missing header files, unused variables (probably copy&paste garbage from previous listings). Once most of the errors you can catch just reading the examples, it is frustating to see errors in a book. They are no big deal, but it leaves the reader with the feeling that the author didn't reviewed his book. It is also important to note that the examples in the CD don not contain most of errors from the listing.
- really bad programming practices. If you run the examples as they are presented, your compiler will complain too much that you will start to avoid to compile the listings at all. If you run a static code analyzer (like splint), you will be even more astonished.

I really would like to give five stars to this book, but due the lack of care, I have to give it four stars.
0Comment|Was this review helpful to you? Report abuse
on September 2, 2007
Looks like I'm going to break the mould of giving five star reviews to this book.

Part I is a brief overview of the history and motivation behind Linux. No bones there.

Part II covers compiler and related tools. I learnt a few things from these chapters (I wasn't familiar with either autotools or gcov).

Part III covers application development. The emphasis is mainly on IPC. There are some grim errors in the code. In particular, I winced when I saw the use of asserts that contained statements performing actions with (necessary!) side-effects. Compiled in optimized mode in most environments, this code will crash. For this section, Stevens/Rago APUE or Rochkind AUP serve much better.

Part IV, shell scripts and tools is OK, as is part V, debug/test.

I'm not sure why there's a CD included. It contains the source code (of little value, easily downloaded) and all of the diagrams used in the book. I can't imagine that they will ever come in handy.
0Comment| 38 people found this helpful. Was this review helpful to you? Report abuse
Written for application developers, this book is a great source of information on working with the GNU/Linux architecture and process model. If you know something about programming but want to know how to use those skills in the GNU/Linux environment this is one of the best books available. The coverage is thorough and filled with coding examples to illustrate the concepts. To make your life easier it even has all the coding examples included on a CD in the back of the book. Areas examined include the GNU compiler, automake, shells, scripting, creating and using libraries, named pipes, semaphores, sockets, and shared memory. The book wraps up with a section on debugging and testing your application. GNU/Linux Application Programming is an excellent source of information for the new to intermediate GNU/Linux programmer and highly recommended.
11 comment| 17 people found this helpful. Was this review helpful to you? Report abuse
on October 20, 2007
Bought this book as it had so many good reviews on Amazon.com. I really should have paid more attention to the one review that said "Disappointing" (Paul Floyd of Grenoble, France).

I haven't yet read the bits about history, tools or shell scripting. What I have read is the section covering application development. This skims through areas such as sockets, threading, semaphores, mutexes, message queues, memory-mapped files etc. All useful areas, but this book does little more than tell you what the man pages tell you. That's where the first bit of lazy authoring comes in. The second bit of lazy authoring is the complete absence of an explanation of how to use these areas together, or an example of using them together. Given the list of topics, an example would have been useful that starts a worker thread to handle a TCP connection, that thread waiting on file descriptors and a timeout using select or poll, using mutexes to protect data, a message queue to communicate between the main thread and the worker thread, and possibly a memory-mapped file to create a circular log of the last N actions performed. Unfortunately the author didn't attempt that. But we should possibly consider ourselves lucky that he didn't, as the example code he does provide contains some major failings, most notably putting code inside assertions that is required even in optimised release builds. When this code gets compiled out in an optimised release build the examples fail. Obvious to anyone that knows about assertions, but not necessarily to everyone reading the book.
0Comment| 16 people found this helpful. Was this review helpful to you? Report abuse
on July 28, 2012
Well-rounded coverage of essential topics for someone who needs to know what is Linux programming. Linux is open source, and there is already tons of information out there on the net. This book provides good perspective if you do not want to get distracted by all the noise online, but focus on developing an understanding to build upon.
A programmer should rather buy this book than something like 'Linux in a Nutshell'.
I disagree with some critical review comments here by other readers.
The author is well-known for his knowledge contributions, especially at IBM open source resources.
0Comment| 2 people found this helpful. Was this review helpful to you? Report abuse

Need customer service? Click here