Customer Reviews

GNU/Linux Application Programming (Charles River Media Programming)

5 star:		(7)
4 star:		(2)
3 star:		(1)
2 star:		(1)
1 star:		(0)

 

 

All the topics that one needs to read to come up to speed with Linux programming, development and maintenance, scripting and even tuning are covered in this book. The author starts with the basic architecture of the Linux operating system, and delves into the details of each part: scheduler, memory manager, virtual file system, network, ipc and init. The reader starts with an overview of what the Linux operating system looks like "under the hood", and is taken thru a series of sections that cover application development using each section of the Linux kernel. Overview application programming, performance analysis and debugging using various GNU tools such as the the GCC complier, make, gcov and gprof are given first and are used throughout the book by the author to further demonstrate the features and benefits of the available GNU tools.

By now, the reader is presented with the necessary tools needed to create application, and is not time to delve into specific programming techniques and API's. The book starts with simple file handling API's and examples, and goes into more complicated topics such as:
* Linux Pipes
* Sockets programming
* Multi-process development and the Linux process model
* Multi-threaded development and the Linux threading model
* Messages Queues
* Synchronization and Semaphores
* Shared memory programming
Even though each of these topics are very complicated and an entire text could easily dedicated to it, the author with elegance covers each topic such that the reader could get an overview of what is at stake. Each topic is rather short, and very well written with examples and a step-by-step instruction of how to write simple programs. Each chapter is like a short and sweet introduction to the topic at hand. One of my favorite chapters is, "Synchronization with Semaphores," in which the author further illustrates the point using sequence diagrams of events, elaborated examples and tips on how-to's.

The chances are that programming in a high-level language such as C is not enough, and one needs to compliment his/her application[s] with scripts and many other available Linux tools and commands. The last section of the book is dedicated to what some people might call odd-and-ends, but to me, they are as important as any other topics in this book. Bash, Sed, awk, flex and bison are some of the scripting languages that are covered. As with the previous sections of the text the author covers each topic using examples plus a step-by-step depiction of each example.

If you are new to the Linux programming environment or you need a refresher text like I did, you will find this book very useful. Tim does a fantastic job covering a broad topic, and doing so with such ease and elegance. The examples are priceless, and the CD at the end of the book has complete source code to the examples given in the book.

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.

I've read several books on programming, and several on Linux. This book covers a ton of stuff, some easy, some complex, but all useful.
I would recommend this book to any programmer wanting to know how to use makefiles, autoconfig, file handling, programming with sockets or pipes, multi-threaded programming, awk,sed, dynamic libaries,flex bison, the list goes on and on.

I don't know that this is introductory, but parts are, and the book can be grown into. It's arranged much better then my list of topics above.

I liked this book so much that I logged onto amazon just to write this review. It is a great book.

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.

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.

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.

This book covers a wide breadth of what you need to get started with Linux programming. The writing is very good and readable.

The examples though simple, are very clear and concise, and makes you understand at a fundamental level what elements of Linux you need to know.
The ones I liked in particular were:
- IPC (interprocess communication)
- Linux process model, and pThreads
- shell scripting, awk, sed
- bison, flex
- tools like GDB (debugger), gprof (performance), gcov (code coverage)
- sockets programming

Note that this book does not go very deep into these topics, but if you need a refresher on the basics, or you don't know a particular area of linux, this book is highly recommended.

Most of the examples are in C, as expected, (being Linux) except for a very short example in Ruby with Sockets programing.

This book is perfect for anyone who needs to write application software for GNU/Linux. It describes all those miscellaneous features for programming that are above the kernel but below the level of integrated development environments. It describes makefiles, gcc, debugging, object file analysis, sockets, pthreads, performance analysis and much more. The latest edition also has an excellent overview of virtualization.

The author doesn't go into detail on any one subject, and that is what makes the book so good. I can find details in various online sources. This book is perfect for someone who had normal training in C/C++ and now needs to understand how to develop on a GNU/Linux system.

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.

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.