Customer Reviews

The Linux Programmer's Toolbox

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

 

 

This book is aimed at the person who has learned his way around Linux at the user level and now wants to look under the covers. It's extremely comprehensive - from how to add a Linux application that wasn't in your your initial distribution - whether you can use the binary or need to rebuild it from source - through basic facts on the kernel, devices and their drivers, processes and debugging tools. There has been a need for a book that addresses readers who do know something about computers, but not much Linux. This book fills that need extremely well.

No, really. The first thing that impressed me is how much information the author packed into 600 odd pages. It takes skill to do that well and still be readable and interesting.

A programmer moving from anything to Linux would find this a simply wonderful roadmap and introduction, but I was surprised to notice that this would also be very good for non-programmers: sys admin or high level support types will like this book also.

There's good stuff here: the subsection of Chapter Two that deals with things that can go wrong during compiles is the best treatment of that I've ever read. Chapter 5 is titled "What every developer should know about the kernel", but most of it is things every admin/support person should know too. Of course there's much more: this is very thorough and complete.

Definitely recommended.

It is a very good reference to Linux developers, by providing the most common seen or most used techniques in Linux developments. It covers from the most used tools, including source version control, source code edit, debug,etc, to a brief introduction on the Linux kernel architecture and memory management, that is essential to any programmers who want to know the "evil" inside the kernel.

Jason

To a new user, Linux is much like a dark room. There are lots of things in the room, but you can't really see them, and you don't know what they are, or what they do. You learn primarily by feeling your way around. Very often, Linux can be frustrating because you can't find what you want, or you bump into something sharp or stub your toe. Occasionally, you stumble upon something valuable...

That's how I learned Linux; I stumbled around long enough to discover many of the important pieces. But, boy! it sure took a long time, and I ended up with an awful lot of stubbed toes!

Well, if Linux is a dark room, then The Linux Programmer's Toolbox is a Wicked Lasers Torch Flashlight with a built-in GPS navigation system. This book clearly explains all the important pieces you need to know about, and shows how they all fit into the Big Picture. If you are a Linux programmer, or even just a Linux user, this book will significantly improve your life. No joke!

I managed to learn many of the things in this book by trial and error over the course of many, many years. I had to use the "stumble upon" approach because I never found a book that gave such a good overview of the available Linux tools, and how to use them. Don't get me wrong -- I read a *lot* of Linux books and documentation; but most of them just gave shallow, unconnected overviews of different Linux commands, or they didn't explain how the various pieces fit together to form one coherent system.

For example, I never found a book that gave a helpful overview of compiling Linux software (like source code I download from sourceforge.net), and so for years, as soon as I hit an obstacle while building a program, I didn't know what to do. It was not until I created my own programs and my own build scripts that I actually figured out how to properly build software. In other words, I had to first become a Linux "Developer" before I stumbled upon all the pieces I needed to be a fully functional Linux "User". It is exactly this "chicken and egg" problem that makes Linux so difficult for newcomers to learn.

The Linux Programmer's Toolbox covers the topic of building Linux software in depth in Chapter 2 - Building from Source. The chapter also goes into valuable topics that even I did not know much about, such as good alternatives to the 'make' utility. Also, this chapter has the best introduction to GNU make I have ever found.

The Linux Programmer's Toolbox has ten chapters altogether, each of which is amazingly valuable, even for experienced users. I personally did not know much of the information in chapters 5 through 10, which are about the Linux Kernel, Linux facilities for inter-process communication, performance tuning, and advanced debugging. For me, this book was an extremely interesting and valuable read. I wish I had this book a long, long time ago! It would have saved me countless years, tears, and stubbed toes.

Read this book! It will save you years of stumbling around in the dark! Your toes will thank you.

~Christopher Sebastian
Phoenix, Arizona

Fusco gathers into one easy to read book the many open source tools available under linux. Cumulatively written by hundreds (if not thousands) of contributors. You might pause a moment when reading the text, to reflect on the amazing amount of code that is freely available under linux.

The tools are meant for two types of readers. The system administrator. The programmer. For the sysadmin, there are tools for install packages. Very practical, since updated packages often have bug fixes or new functionalities. This includes rpm, which is used by Red Hat, Suse and other linux distributions. But dpkg is also explained. This is used by Debian and Ubuntu. For the programmer, tools include ways to share memory between processes, as well as communicating between them via semaphores or message queues.

The book reflects a general approach taken by Fusco. Tools are described across the popular linux distributions. The book can be used by you, regardless of which distribution you favour.

There is a stylistic difference between the material in the book and a corresponding text on Microsoft's offerings. The latter often has a rich graphical framework, like Visual Studio. In contrast, significant portions of this book refer to tools used at the command line. Reflecting linux's heritage in unix. Which means that portions of the text might be initially more complex to master.

I had high hopes for this book, as others have recommended it to me as a good way to familiarize myself with the number of tools available for programming in the GNU environment. I would like to have joked, saying that since the author uses vi, and I use Emacs, that the book therefore gets two stars. Unfortunately it's not a joke, and I have some negative comments to make about this title. The author generally makes a good effort to educate his readers, and I really like his attitude and the inclusion of comedy: for example, using the number 0xdeadbeef in examples, and a footnote stating that if you've never had a GUI unavailable "you're not trying hard enough." From comments like this, I can tell that the author and I would have a good time chatting, but the book just doesn't go far enough in terms of useful information.

I do recommend this book for GNU/Linux novices, but unfortunately cannot recommend it to other people like myself, who have been using GNU/Linux for more than a few years. If you are an experienced programmer on a different operating system or programming environment, then this book will have a lot of good introductory material. The book includes plenty of good information about how system calls work, how the kernel allocates memory and some other system details (most of which can be found in another title in this series: Linux Programming by Example: The Fundamentals). I found the section on vi and Vim to be the best summary of important commands I've found anywhere. Consider that these useful facts only fill about thirty of the over 500 pages of this volume.

However, the content is only introductory. Although this text includes many examples, you won't find much in the way of real programs, or in-depth discussions of how the utilities work. You will find a similar level of introduction in the lead paragraph of Wikipedia articles on each topic. Of course it's better to have it in one printed book, but this book is too heavy for the amount of useful material.

Much of the material was old hat to someone like me, with over ten years of Unix experience: there's very little that can't be found by reading documentation (for example, the info pages that the author so heartily recommends). Beyond that there are a few telling omissions and errors: the author does not mention Subversion at all, for example. His section on Emacs concludes by saying that there used to be two different versions of Emacs (GNU Emacs and XEmacs), but they are now "one big happy executable." This is just plain wrong: GNU Emacs and XEmacs are separate projects, with different development paradigms, different user communities (for the most part) and they are run by totally separate organizations. Every Emacs user knows that.

Another thing that irks me is the title: this book is not about Linux (the kernel), it is about using the GNU programming environment. It should be called "The GNU Programmer's Toolbox."

For experienced programmers, I recommend GNU/Linux Application Programming (Programming Series). For GNU/Linux novices, I recommend getting this from the library, reading the chapter on documentation, and then reading that documentation (most of which is on your computer!).

...and refreshingly so. It does not start out with the same story about a boy in Helsinki (very glad he did what he did tho), but jumps right in with getting the tools and dealing with package managers and even source codes in the process. Next he describes collecting the docs, and using editors to deal with configurations.
It appears to be a book not written by a professional author, but probably a once only tome by a man who has much to share to others in the hope that more can effectively use this life enhancing phenomenon called Linux.
Process schedulers... device drivers... debugging... this is a WORK book. period.

This one is in the same league as

"Linux Programming by Example: The Fundamentals"

in the same series. Chapter 2 is an example that explains the build tools very well. These solid books are for serious learners and practitioners of Linux.

Overall this is a great book. It collects a lot of information in one place and gives a lot of insights and tips on programming in Linux. The only down sides I see are that it is somewhat VI heavy (and emacs light) and the dumb light saber on the cover. I am sure that the author is a vi user, so that can be excused I guess and he probably didn't get to pick the cover. I know Prentice Hall wanted to have a theme for the "Open Source Software Development Series", but all Linux programmers are not supernerds that go crazy over anything Star Wars related. Anyway, I would highly recommend this book to anyone wanting to take their Linux use to the next level.

Really, don't buy this just yet. I own it. I've read all of it. It is almost the exact same content as the official linux programming guide. [...] . And this teaches better coding conventions. Honestly the writing style in the book was a little confusing.

As far a programming books go it is better than average so I feel bad giving it one star but really this information is free and better written elsewhere.