Linux Books

I first reviewed this book in the AZTCS Journal of October 2007.

There are things I don't like about this book.

Bible status, I think not!! If there is a Bible for Linux this isn't it. Enthusiastic Beginner's guide. Yes. Bible, no!!

In Chapter 3, I'm disappointed there isn't more detail about alternate window managers. I think too many people feel KDE and GNOME are the only choices available ... or the desktop is Linux ... or don't know they can start with a blank xwindow and make their own desktop and menus.

The book should include more about shell scripting, not so much to teach it as to give an idea of the power available. I feel slighted he didn't mention Emacs in the text editor section; honestly I think this is a tremendous oversight on his part as Emacs is a popular and powerful text editor.

The 250 + pages is too much to spend on specific distros in a book with Bible in the name. Almost 1/3 of the book is wasted and could have been put to better use or left out.

There are several things I like about the book. I think it gives an objective view of Linux. The author introduces and quickly acquaints the reader with the command-line. Many authors seem to feel the command line should be avoided, but Negus plunges in Chapter 2 and makes the use of the command-line, if not easy, at least not scary. The command-line is a part of Linux. He is not afraid to expose his readers to the terminal and to its use.

Chapter 4 covering basic administration is very helpful. He gives a lot of good information here about log files with excellent explanations.

The CD/DVD collection contains an excellent range of distros (of course most are out of date by the time the book is released) ... from a distro that will run from a floppy (I recently used a floppy distro to fix a forgotten password in Windows XP) to some desktops that are a little cramped on a PIII with 512 MB memory. Negus shows, although there are some specialized distributions, most have the tools and versitiliy to handle any task. If you want to surf the web and check your email and chat on-line, build a full webhost, add a firewall to your home network, recover files from a crashed Windows system or are looking for something VERY interesting to do with your computer, Linux probably has something for you.

I think this CD/DVD collection should have been a chapter with links for downloading the latest versions instead.

His instructions are generally clear and concise. Where necessary, Negus gives step-by-step examples. He explains but, to me, manages to balance between over informing to the point of boredom and talking down to the audience. I read 2 or 3 of his other books and his style generally is informative and as technical as necessary but not overly so.

Of the several beginning to intermediate Linix books I read in the last few years, this book is the best so far. As a Bible, I don't think it is up to that status. I am rating it on the good parts and comparing it to other books available on the subject. I think the useful parts make this book above average.

I'm new to Linux. I've been using it for three months. I was looking for a fairly inclusive book so I could learn more. I didn't find this book terribly helpful to me though. Mostly I used the discs that came with the book to try out the distributions contained. So, on to the book ...
The first 1/3 of the book deals with the "shell" - Choosing a shell (fairly esoteric for somebody like me), and running commands from the shell. Unfortunately, the book never gives any comprehensive list of commands in one place (this would have been quite helpful). The commands it does give are scattered throughout the section. Also covered are basic administration, securing Linux, running a firewall/router, getting into the desktop and getting on the internet. Most of it except "Getting into the Desktop" seems geared more toward system administrators than standard desktop users. As written, I doubt I'll ever use the first third of this book even as reference material.
Approximately the next 1/3 of the book deals with choosing and installing a Linux distribution. It covers the distros that come with the CD and DVD included with the book - a total of 12 distros - excluding alternate installs and 4 specialty programs such as Coyote Linux (floppy firewall), INSERT (I don't know what this is and I don't see it in the index or contents), BackTrack and System Rescue CD. (This leads me to the fact that the index left a lot to be desired.) This being said, this third of the book was a good and helpful companion to the discs.
The next part of the book deals a bit with running bootable distributions but mainly with running applications such as word processing, Internet browsers, e-mail, playing music and videos, image editing and gaming. I can't comment on this - I merely glanced through it. I tend to figure this stuff out myself. I'm sure it would be helpful to many people though.
The rest of the book (about a quarter of the book) deals with running Linux servers and programming. I'm not running e-mail, print or file servers and so had no interest in Apache, LAMP, SQL etc... but I'm sure there was some good information there.
If you want a book that comes with a dozen distros and is a rather helpful companion to the installation and basics those distros, this is the book for you. But overall, for my purposes, I'd give it an average rating.

I wish I'd bought this book first - it would have saved me a lot of frustration (and $$) in trying to find a Linux distro (version) that would actually work on my evidently odd combination of hardware.

Thanks to the DVD and CD that come with this book, I was able to find 3 different Linux distros that work just fine on my computer (I'm using one of them right now, in fact). I'd say the best part of this book, at least for me, is definitely the included DVD and CD - especially since I'm on dialup and it's not practical to try to download a bunch of different versions of Linux, to find which ones are compatible with my hardware. The DVD and CD itself is worth 5 stars, in my opinion.

Before buying this book, I'd previously bought a *different* book, whose DVD featured only one version of Linux that everyone raves about (it's supposedly user-friendly and all that), but that other book and Linux version was a total waste of my money because that particular Linux distro had too many major incompatibilities with my hardware, and I was unable to make it work. I spent a good solid week doing web searches trying to find workarounds to make it work (using my other computer to do online research, since I couldn't even get that far with Linux), but it was hopeless. I figured that if one of the most popular and most raved-about Linux versions couldn't be made to work, then what chance would I (as a total newbie) have with other versions?

It was at that point that I gave up on Linux for several months, concluding that Linux was over-rated and worthless. But I was not happy about that.

But, after a while, I decided I couldn't just let it drop like that - I wanted to try some different versions/distros, to give it another try. So I bought a different version/distro of Linux, on DVD, but that one had an entirely different set of problems and it was useless too. More money down the drain.

But, my "last chance" to make something of Linux, then I ended up buying *this* book, which turned out to be a good idea, because as I said, this book's DVD and CD has enough different versions/distros of Linux included with it, that it greatly increases your chances of finding one that will actually work for you. If I'd bought this book *first* I could have saved myself all that aggravation.

So, thanks to this book, I went from being a Linux newbie that couldn't make Linux do anything at all, to finding a distro that I'm actually comfortable with, that works great for me.

I agree with what others have written, that the book itself may not exactly be up to "Bible" standards and once you find a distro that works for you, you may want to supplement the book with some additional material. But it got me started with Linux, which other books and materials were unable to do.

- J2000 - and now Registered Linux User #454273 :-)

The book is an excellent overview of Linux. I highly recommend the Linux Bible to get an idea of what is available in linux and to chose a distro. However, and this is not a flaw in the book, to become more that a windozer, one must read at least, Garrell's, "Introduction to Linux", available online as opensource. Without proper maintenance linux will soon be clogged, useless and hacked, but at least it will still be free!!

The CD/DVD combination available with the book, is very helpful and quite a time saver.

Knowing that I need to spend some time learning about Linux I went looking for a book that would be a general introduction to help me get started. This book attracted my attention because it has an individual chapter talking about the special features about the distributions that are included with the book. I don't know how many distributions there are - over a thousand, I think - and had no idea about the best one for me to pick. After reading the book I'm going to try Ubuntu.

This is an excellent book on getting started, but as a Linux Bible, I think the book is mis-named. It's strength is talking about the distributions and the fairly general things you can do with Linux. It's a bit weak in the details of how to do things. As such, it's a great book to use when you are getting started. Then you will want more books to talk about the individual software packages that you'll be using. For instance he talks about PHP, he tells you how to get it running but once you start you'll want a programming book on PHP.

Concise and very handy. Guides like these aren't meant to be a complete reference on iptables. Yet, the author managed to pack quite a bit into such a small book. 82pages from page 1 to beginning of index.

21 pages to theory and operation -- connection tracking, accounting, NAT, SNAT, DNAT, Transparent Proxying, load balancing, and stateless/stateful firewalls.

The next 61 pages are a command reference to iptables. It is in the command reference that you shall find interesting little nuggets like:

1) How to rate limit incoming traffic. Specific examples provide for allowing only 10 pings per second.

2) How to setup IP pools to match source and/or destination addresses. Instead of writing a line for each IP or netblock, throw the addresses into a pool and write a line for each pool.

3) How to match multiple ports on the same line.

and so on.

Worth every penny. Lives up to O'Reilly name. Would recommend for every Linux sysadmin.

Last year, I was forced to become a fly-by-night system administrator. I worked for a small, local startup as its web developer, but was thrust into a sysadmin role when my boss decided to host a website on a server in our office. I was developing the site on our Ubuntu server, but was learning how to secure the server on the fly. This reference, out of all the other books I read and sites I visited, had the most bang for the buck.

It's short and sweet. It describes what you should know, and gives you a reference for dealing with iptables syntax, and that's it. No flowery text, no colored pictures. Just simple "This is how to do X."

If you're a sysadmin, especially if you're just getting your feet wet, get this book. It's cheap, it tells you what you need to know, and it fits in your pocket. What's not to like?

This book is written for linux/unix sysadmins, not programmers. The topic of iptables is intimately related to guarding a network against intruders. A sysadmin task. Plus, the compact, pocketbook size lends itself to a common scenario.

You're a harried sysadmin in the machine room of your company, surrounded by racks of computers and cabling. Equipment everywhere and little room for you to prop up a regular sized text on intrusion detection. Quite possibly, the master console is some cheezy old monitor that you got stuck with. Or even worse, it is just a terminal. If the latter, it's really awkward to do a man on iptables and also run it, especially if you're in real time mode against an active intruder. In other words, what this book is ideal for.

'Linux iptables Pocket Reference' is an important and sorely needed reference to iptables, the interface to the Linux packetfilter used by System Admins to create firewalls, NAT routers, transparent proxies, and other 'magical' network devices. While not a tutorial, it offers good advice for those with a grasp of basic networking concepts, and a good notion of what a firewall is and what it is used for, in a dense and concise format. Sufficiently detailed information about the protocols involved obviate the need to keep additional references at hand, and make the work relatively self-contained. This should not be the first book you read about firewalls or tcp/ip, but if you are a networking professional, a technically oriented user, or just interested in creating special purpose network devices, this book belongs in your library. Those familiar with iptables will especially appreciate the lucid description of packet flow through the tables and chains, and the supporting diagrams ... they alone are worth the price of purchase.

If you have need for a book on the topic, you will not be disappointed with this one.

Linux iptables Pocket Reference is a great book.

there is a dearth of info on Linux iptables, and this pocket reference is a great book!!

The Linux Programmer's Toolbox discusses open source tools available for GNU/Linux, describing the most useful tools available and using plenty of examples on how to modify them for Linux needs. From learning how Linux interacts with software and understanding the basics of the Linux kernel to interpreting tools and applying it to applications, THE LINUX PROGRAMMER'S TOOLBOX comes packed with tips on how to streamline and customize processes, making it a pick for any serious programmer's collection and any library strong on Linux applications.

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.

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.

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.

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.

"Linux Troubleshooting Bible" is another excellent book by Christopher Negus. Although the focus is on the Fedora Core 3, it is still packed with information for the beginner as well as the experienced linux user. The book contains tons of information with excellent examples of commands, just about everything you need to know when using linux. The companion CD's include a DVD with Fedora Core 3 and CD-ROM containing the Debian 3.1 (sarge) release.
I have three "must have" books on linux: 1) "Linux Troubleshooting Bible" by Chris Negus, 2) "Linux Bible" by Chris Negus and 3) "Red Hat Fedora and Enterprise Linux 4" by Chris Negus. You can't go wrong with these books!

This book contains a great amount of information regarding the troubleshooting of key services like Bind, Samba, NFS, Apache, FTP, SSH, and Sendmail. I found very useful information related to printing services, system tools, and backup solutions. The book contains some key "Tips and Tricks" that seem very useful for the everyday issues I see as an administrator. As and RHCE and experienced system administrator, I found the book very useful and find myself picking up the book very often to review and test some of the ideas mentioned on its content.

Linux systems have become easy enough to use that you no longer have to be a computer expert to operate a Linux desktop or set up a simple server. However, making the leap of faith to bet your organization on Linux requires a decision to:

* Purchase expensive support contracts from Red Hat Inc., Novell, Inc. or some other Linux vendor, or

* Take the responsibility to configure and troubleshoot Linux yourself.

Knowing how to safely deploy a Linux system on the Internet, or debug server software or desktop hardware, can take years to develop. Contributors to the Linux Troubleshooting Bible condense their years of experience into a few hundred pages that will set you on your own road to becoming a Linux guru.

I put together the team of writers on this book to save you the thousands of hours it would take to start from scratch learning Linux troubleshooting on your own. Among the contributors is Tom Weeks, who trains technicians that support and protect literally thousands of Linux systems at Rackspace Managed Hosting, and Jesse Keating, founder of the Fedora Legacy Project, which provides critical security updates to Red Hat Linux and Fedora Core Linux systems. I've tried to leverage more than 20 years of my own experience writing about UNIX and Linux system administration to make the information interesting and entertaining.

I took on this project because I felt strongly that the Linux community needs cohesive resources to take the Linux enthusiast forward to where he can become a skilled Linux professional. With a focus on Red Hat (Fedora and RHEL), Debian, and SuSE systems, I hope you find the Linux Troubleshooting Bible to be a useful way to expand your hobby into a powerful profession.


-- Chris Negus
Co-author Linux Troubleshooting Bible
Author Red Hat Linux Bible (all editions)

This book hasn't been of much help to me. My review might be too strict. This book may be useful to people running Linux on servers and networks.

But to the average desktop user, I'd dare say, it's useless. Linux has been very smooth to me so far. I've used SuSE and use Fedora Core. All (minor) problems that I've faced have been easily solved through the various Linux forums.

I have not read this book cover to cover and this may be an unfair review but, still, I can't recommend it to the average user; either newbie or advanced. System administrators should not read my review!

Anyway, the book focuses a lot on Fedora Core 1. It has two chapters for Debian and SuSE. I guess that if this book addressed more to system administrators, it should focus on distros like Red Hat Enterprise Linux or Debian.

This book is the best I've ever used for working on my systems. Though it leans heavily on the Red Hat and Fedora distributions, the reader can apply most of the information to their favorite distribution. If I hadn't used it, I never would had known that BIND is now chrooted.

'MySQL in a Nutshell' is another solid release in the family of 'Nutshell' books by O'Reilly. As with all other Nutshell books, this isn't a learning book, moreso a shorter reference manual for experienced developers who know what they are using and need a guide to help them out through the process. With MySQL In A Nutshell you are getting exactly that. Spread over nearly 550 pages and 19 Chapters, here's an overview of the content within:

01. Introduction
02. Installing MySQL
03. MySQL Basics
04. Security, User Statements, Functions
05. Database And Table Schema Statements
06. Data Manipulation Statements And Functions
07. Table And Server Administration Statements And Functions
08. Replication Statements And Functions
09. Stored Routines Statements
10. Aggregate Clauses, Functions And Subqueries
11. String Functions
12. Date And Time Functions
13. Mathematical Functions
14. Flow Control Functions
15. MySQL Server And Client
16. Command-Line Utilities
17. C API
18. Perl API
19. PHP API

The layout is good, separation of data is intelligently laid out and the writing is solid. If you are a MySQL developer or admin that is looking for a resource by your side at all times this is a great book to have!!

***** RECOMMENDED

It's a great reference but dated. If I had known that it only covers through version 4, I would not have purchased it.

The book is "A Desktop Quick Reference" just as billed on the cover. It is explicitly MySQL-centric and doesn't stray from that core message. It is extremely up-to-date considering the rapidity of movement in MySQL development progress.

I feel that its author, Russell Dyer is the kind of person who is easy to talk to and immediately be comfortable with based on his style and presentation in this book.

The content of this book is very well organized in keeping with the finest traditions at O'Reilly & Associates. There is an installation guide, tutorial, SQL syntax reference, MySQL built-in functions section(s), command-line utilities reference and programming languages API references for PERL, PHP and C. These API references demonstrate commonplace MySQL usage through clear, easy-to-read examples that make good sense.

It is a very comprehensive text that reads as easily as a favorite novel yet is concise enough to be your first "go-to" on MySQL issues you may face day-in and day-out. It is truly the "most advanced kingfisher" (cover animal) on the topic and, like the Pied kingfisher, it is lightweight and demonstrates keenly honed survival skills.

I use MySQL daily and I find it very useful and enjoyable. I don't want to become an SQL guru or even a DBA, as a programmer, I enjoy having MySQL In A Nutshell close at hand so that I can focus on writing code. Thank you Mr. Dyer (and the folks at O'Reilly) for a job well-done! I heartily recommend it to everyone using MySQL. The convenience of this publication clearly outweighs its cost. Newcomers and RDBMS "old-timers" will appreciate this book equally.

Well the book certainly seems to cover MySQL's features quite comprehensively. But, as it is a reference manual, it does not attempt to teach you MySQL or the theory of relational databases. For a given MySQL command, the book's explanation is succinct and useful. Provided you already have a background in the area. Much of the book's discussion is probably already available in equivalent form in the online help. But hardcopy is nice to have.

Going through the functions, what you might appreciate about MySQL is that many of these are generic SQL functions. If you come from any other SQL implementation, your background will be relevant to much of the book.

Ah, "Nutshell" books - you gotta love `em. Or maybe you don't. I won't get into the pros and cons of online documentation versus books because this subject has been rehashed ad infinitum. Truth is, there are pros and cons for both, and we each have our own reasons for our own preferences.
That being said, if you like book documentation - and "Nutshell" books in particular - then you will like this book. I happen to think it is a good idea to tear yourself away from the keyboard/screen every once in awhile, and the "Nutshell" books give you a good reason for doing so.
I'm not a SQL expert, so I liked the tutorial-flavored introductions at the beginning of each chapter, followed by the conversational tone of the clear and concise examples. I did not have this book when I first started programming using MySQL, and that's too bad because it could have saved me a lot of wasted time with its explanations of some of the more nefarious "gotchas" of the language.
I have but one criticism and one suggestion:
Criticism: The following APIs are covered at the end of the book: Perl, PHP, and C. I can see leaving out COBOL and Lisp (if there are even APIs for these languages), but Java? Granted, the Java interface to MySQL is well-documented in many places, but if you are discussing the *major* programming language APIs to MySQL then you should do just that.
Suggestion: The beginning of the book provides an introduction to MySQL via command-line instructions. I can see doing this, even though no one interacts with databases through the command line. What I think would be even more useful would be a brief discussion of the two tools that everyone does use: MySQL Administrator and MySQL Query Browser. A couple of chapters (along with some screen shots) of what they are, why we need them, where to get them, and how to use them would really make this book perfect. (If you don't forget that Java API chapter!)

This book is perfect for someone new to the world of GUI programming. It provides a detailed walk-through of generating a useful and robust user interface. Providing a firm foundation in python and OOP and then adding both knowledge of Qt and a best practices approach to GUI programming.
If you aren't new to programming and GUI creation than this book is still a very useful source of information if a bit hard to get through. The feature this book lacks which many love in O'Reilly books is a component by component breakdown of features with good examples. This is not really a flaw as this book is a ground up approach, however if you are looking for something akin to PyQT In a Nutshell you won't find it here. That being said, it is the best book on PyQt4 out there, and even if there were many other PyQt4 book to choose from this is still an excellent learning tool.

In short this is an excellent book for people new to Python and Qt, especially those without GUI experience. Those with more experience may be bothered by the lack of a more modularized approach to learning PyQt4 as this book follows a more chronological approach of the design process. It's not quick and dirty, but it is robust and well written.

I've been programming in python for about 2 years, and programming in PyQt for about a year. But I haven't had time to really delve into how things work, and how they relate to each other. The on-line documentation falls short in this area, so this book is a great help! I learned some new stuff about Python in the first few chapters, but the biggest help was the explanations of how PyQt works, and how to use it to the best advantage.

Advanced programmer libraries and any versed in Python in particular will find RAPID GUI PROGRAMMING WITH PYTHON AND QT an invaluable guide, covering the mechanics of building GUI applications that run on all major operating systems. From custom widgets to advanced model and view programming, this book's depth and technical detail lend to any serious programming collection.

For any open source programming tool, there are always those who are quick to point out that free online documentation is of excellent quality and that a commercially published book adds questionable value. Indeed, the open process by which open source tools are made, which reveals the why's & wherefore's of the internal workings to anyone who looks, leads directly to the production of excellent online documentation; this is one of the great strengths of open source software. But everyone's needs are different. A college student or free software volunteer often has looser deadlines, less budget, and a more perfectionist attitude than, for example, a non-expert programmer, working in industry, trying to expeditiously solve a specific problem. A book of this genre is intended mainly for the latter audience, whereas the former may be disappointed at spending $50 when a web browser could have done the job. Cash-strapped college students, I know your pain; I used to be one. This book is not a particularly cost-effective study aid. If you live and breathe GUI progamming and can type out GTK2 and wxwidget classes by heart, then this book is probably a waste of time for you.

Having said that, I review this book with a view toward its value to its intended audience: Does buying this book and using it get the job done $50 cheaper, including the value of your own professional time, compared to the best available alternative? My experience is yes.

I am an electrical engineer, but not a programming expert. I have, at various times in my career, flipped bits in assembly language, suffered the rigors of Fortran, and slapped together contraptions in Matlab, VEE, Labview, etc. I have also had the misfortune of programming production test automation in Visual Basic, because that is what commercial instruments natively support. It is the shortcomings of VB that bring me to PyQT. I need to write test code that is portable, maintainable, and reliable. To give just one example, I don't want to fly across the Pacific Ocean to program workarounds for bugs in VB, because machines in the Chinese factory run Win98, and my development system in the US runs Win2k, and VB doesn't behave the same. But this is a book review, not a place to extol the virtues of PyQT nor criticize VB.

I have programmed in Python before, though for me Python has always been a language for one-off numerical or string processing tasks, where a spreadsheet is too limited and my bash script-fu is short of the task. I found the first three chapters on Python a helpful review, though it is not a complete instruction in Python. Compete beginners to Python will probably want to buy a separate book or work through the python.org tutorials. The author glosses over things that could trip up beginners; tellingly, he uses the term 'pythonic' without introduction. He is, however, careful to point out pitfalls that can waylay real-world production code, or would be of interest to experienced Perl/Ruby/VB programmers, like how Python handles the distinctions regarding {im}mutable types and {deep|shallow} copying.

I have never programmed QT before, and this book is indeed a complete introduction to QT. You don't need to know anything about QT nor how to program in C++ (QT's native language). Being able to read C++ syntax helps, though, because this book is not a QT reference, so you will probably have to look things up in the online QT references, which are written in C++.

It is something of a truism that the best way to learn a language is to read & understand someone else's well-written code, and then use that to write a program of your own. That is the approach used here, and the printed book format permits interleaving fragments of code with explanatory material in a way that doesn't work well on a computer screen. As such the text complements rather than duplicates the online documentation.

Regarding the book as a physical object, the quality is good but some extra features would have been nice. No CD is included, which I consider an oversight for a book at this price. Even the shortest examples lack source code listings, except as snippets woven into the text. You have to download the example code from a URL buried in the introduction, which is odd considering how important the example code is to this style of instruction. Occasional sidebar topics, icons, and cross-references help to organize the material, though not to the spoon-feeding level of "For {Dummies|Idiots}" books. The index is a bit above average for a book of this type, better than pure machine-generated grep output that sometimes passes for an index these days, but not as good as the best manual indices of decades past. The cover, binding, & paper stock are of decent quality. The book will stay open to just about any page when laid on a table, and the glue looks like it will, well probably, hold the sheaves in for many years. No color is used, nor edge printing to help find the chapters, which would have been helpful for a book this long.

The book contains one of the best Python introductions I've seen so far, which means it's useful even when you don't know Python, yet. After the introduction, you'll love it :)

After that come 19 chapters which are packed with useful information in well digestible bits so the reader won't feel overwhelmed. When you're a professional, you won't waste time finding the information you need and when you're a beginner, you can easily follow every step as the author builds the examples from ground up.

When I started with PyQt, I was a seasoned Python developer but I knew little about Qt. With the help of the book, I could write a complex application using even more complex widgets like QTextEditor (including HTML formatting) in a very short time. Developing was a very nice experience because the book always seemed to contain just the answer that I was looking for.

What I was looking for in this was a book explaining IPTABLES. What I got was much more. The book starts with overall theory and firewalls in practice, basics off the major network protocols, TCP, UDP, and then moves into the how-to's and breaks down the iptables commands. Script examples are great, already put some of his suggestions into practice.
Would recommend to anyone building a Linux firewall.

The book was very informative. However after finishing it, I was stupified to discover that there is no online errata and/or script download site. (Or if there is one, it is sure hard to find). It seems that Wiley and "RedHat Press" are hopelessly behind the times. This is a serious flaw in an otherwise very useful book.

I was looking for a good book on iptables and this book exceeded my expectations. RedHat Firewalls provides a great description of ipchains, iptables, and also some good sample scripts. In the past, I used the 'Linux Firewalls' book, but if you're running RedHat systems, this is the book for you.

Half of the book was 'into to firewalls' stuff, which may come in handy for someone new to firewalls entirely. I would have preferred more info on troubleshooting.

I wish this book was released a year ago! I spent a great deal of time and energy figuring how to set up and configure a Linux IPTABLES firewall. I did it the hard way. I dug up information from many sources and finally accomplished my mission.

This beauty of this book is that the author has put everything you need in one place. It gives the reader a good conceptual understanding of the concepts and then goes into detail on how to build your firewall. It also contains actual IPTABLES code that you can use with little modification.

Great book! Thanks Bill.

Although I am not finished this book, halfway, I feel compelled to review it. The book has great humor, good info, and makes a very dry read interesting. Although it does not go into great detail on implementing firewalls in the real world, it does have all you need to get moving on your own. I wish that it covered implementation in greater detail but then again most linux guys want to "feel" smarter by figuring it out on their own.

Wilding and Behman take us deep into diagnosing problems that can arise under linux. It seems best suited for an experienced developer or sysadmin. The issues it deals with tend to require this. For example, in many instances, the text gives example assembler code, for the x86 architecture. Most programmers, even when debugging, simply do not need to know the assembler version of their code. Or how the stack works.

However, for those of you who do, the text can be very useful in explaining what really happens under the bonnet, when you compile and run a program.

The book's cover suggests that it can also be useful to power users. I'm somewhat dubious of this. The most that a latter user might do or can do is to hand over a core dump or a screen capture of some diagnostics, to a programmer. Where the latter is the one who avails herself of this book.

The book devotes an entire chapter to the GNU debugger, gdb. More readable than the official GNU documentation on gdb. Given gdb's widespread use across of linux, and indeed over most versions of unix, this chapter may be the most helpful in the book, to some readers. It's a usage exposition that is distinct from a reference manual. Also, given the wealth of user interfaces these days, the text shows how to use a UI front end to gdb, called the Data Display Debugger. While some gdb purists might scorn this, and revert to their trusty command lines, others will welcome the DDD.

If you have been looking for help on gdb, the book is a good answer.

I'm not sure I've ever given a book 5 stars, but this hits me where I live. The only complaint I have is that the title is misleading: it should have been "Learn how to troubleshoot any Linux problem you ever see" or something like that.

I once thought I'd like to write a book on trouble shooting and problem diagnosis. I'm glad I didn't, because this would make me feel like I had wasted my time.

This is truly excellent. I have already learned more here than I have anywhere in the past year, and look forward to spending a lot more time with this.

Whether you are a power user or a Linux system administrator if you like to work through and resolve problems yourself then you will want a copy of this book. The purpose of the book is to provide the reader with a best practices manual and guideline for how to approach and resolve problems in Linux. The first chapter is an introduction that includes the four phases of investigation and determining the difference between a symptom and a cause. From there the author leads the reader through how to use various tools to locate exactly what is happening. The rest of the book examines the details of the Linux system and includes items like using strace to trace system calls, using the information in the /proc filesystem to troubleshoot a problem, compiling the Linux kernel and how to deal with various compilation problems, the GNU debugger (a particularly good chapter), dealing with Linux crashes and hangs, using KDB to debug kernel problems, and the executable and linking format. Appendix A is a listing of common utilities for resolving problems, when to use them, and where to find them. This is a very good resource to keep handy when you are looking for the right tool but really don't know what it is. Self-Service Linux is highly recommended for all Linux power-users and administrators.

If you build software targeted for the Linux operating system, odds are you're going to run into a sticky problem now and then. You'll need to know how to debug either your program or the Linux kernel to see what's going on. This book can help you with that chore... Self-Service Linux - Mastering the Art of Problem Determination by Mark Wilding and Dan Behman.

Contents: Best Practices and Initial Investigation; strace and System Call Tracing Explained; The /proc Filesystem; Compiling; The Stack; The GNU Debugger (GDB); Linux System Crashes and Hangs; Kernel Debugging with KDB; ELF: Executable and Linking Format; The Toolbox; Data Collection Script; Index

This book has some pretty heavy-duty stuff it covers. It starts out with a well-thought-out methodology for debugging a system problem. These first 40 pages are like gold, and they'd be well-applied by *any* system developer, not just a Linux programmer. You'd think that developers would already know this stuff, but sadly it seems like a lost art all too often. From that point, things get deep into the different techniques for debugging problems specific to different areas of Linux. You many not need all the different sections, in that it may just be *your* program, not a problem with the kernel. But having all the information on debugging techniques in one place should cut down on a lot of research time, and will lead to much quicker system resolutions.

As Linux continues to grow in the market, I see the need for solid debugging skills to also be on the rise. This book will likely have a long shelf-life...

(long review)

I have just finished reading through the book Self service Linux from Wilding & Behman.
Let me point out, that when I read the description first I thought that it would be a troubleshooting & performance tweak guide.
However when I read through the first chapters I believed hat the title should say "Troubleshooting (GNU) Linux using Compiler and Debugger".
Finally after I read the whole book I decided the book deserves a different title something like

"The high art of problem investigation and software debugging". - I explain why below.

O.k the title issue out of the way lets focus on the contents of the book.

Table of Contents
Preface.
1. Best Practices and Initial Investigation. - (40p)
2. strace and System Call Tracing Explained. - (50p)
3. The /proc Filesystem. - (30p)
4. Compiling. - (30p)
5. The Stack. - (40p)
6. The GNU Debugger (GDB). - (80p)
7. Linux System Crashes and Hangs. - (20p)
8.: Kernel Debugging with KDB. - (10p)
9.: ELF: Executable and Linking Format. - (85p)
Appendix A: The Toolbox. - (13p)
Appendix B: Data Collection Script. - (12p)
Index. - (10p)


You can already conclude just by looking at the TOC that most is compiling and debugging related stuff.
So to make it clear, this book is NOT for the faint hearted neither is it for beginners. It is for the professionals class room, Power users,
Sysadmins, engineers etc. which either have 3-5 years Linux experience, are in need of a thorough understanding or are looking into developing software.

This is also backed up by the fact that Wilding has 15 years experience writing software and Behman 10 years
experience with (GNU) Linux alone.

Now, if you think 10 years back (1996) you will probably remember that GNU Linux was not that major yet.
So you can assume that Wilding and Behman carry "some" pioneer spirit which is reflected in their book all the way by
the rich details in every single chapter.

The book doesnt loose a lot of time and explains in Chapter 1 (The Intro) an overview of the investigation methods
and also spends an extra 10 pages for the symptoms versus cause explanations with its possible solutions.
That described experience alone can be an invaluable and a BIG timesaver.
If I may make a recommmendation: Make sure you read Chapter 1 thoroughly and DONT SKIM OVER IT !!
I made the mistake and skimmed over it. Almost at the end of the book I realised that many of the questions that
came up for me where caused by not having read the first Chapter thoroughly enough.

Having never done an strace before I found the strace chapter to be very detailed *almost a bit overwhelming for a second chapter.
Developers and senior IT professionals might feel here right at home. I found that the book is overall very detailed and contains so much information that I have
to admit I did not crasp all on the first read ;-). Especially the chapters about Compiling, the GDB and ELF are incredible detailed
and very thoroughly describe many steps which are absolutely necessary investigating software issues.
It is this thoroughly prepared "learned lessons" which the authors describe which makes the book so valuable.

Many people out there may have some experience with debugging and compiling and the typical three commands
"configure or make config, make and install", may have read the one or the other howto.
It is this book which takes those bits and puzzle peaces and allows you to put it together to see the whole picture
of how the software stuff works on the inside of your box.

Instructors and Teachers might use the book for prepareing tutorials and howto*s for classrooms or study courses.
There is enough info inside to make lots of them. It is also a very nice self study book.
The book is very readable, which is especially surprising considering the complex topics Wilding and Behman
are takling.

I personally enjoyed most the chapters about the /proc filesystem and the ELF. However I have to admit that ELF
(the default format for shared libraries and executables) is by no way a simple topic and I had to take a break several times in
order to be able to stay focused and remind me where I am. f.e. In the ELF chapter Wilding and Behman describe 17 of 29
Section names and types * which is a lot *.
They do not only describe their functions, but also their correlations and their importance in the debugging process. A this isnt enough,
Wilding and Behman step you through several debugging process and documented almost each single step I could think of - a gesture
which is very helpful, not only for beginners. They also explain the symbol resolution thats going on internal of the ELF files.
Finally they even explain 2 interception methods, including one showing you how to attach to a running process and debugging it !!

I could feel that this book is written with a lot of passion for a great topic. This is not only a compliment for the authors but also for the team behind the book.
The book is a VERY VALUABLE CONTRIBUTION - not only but - especially for junior members in the open source community.
I also believe that it is a very nice text for the classroom or selve study courses.

If you read until here, chances are high that you will like the book.


Summary:

Its nice to see such a thoroughly prepared text about compiling and debugging which is so readable.
The book allows anybody who has read a few howto's and was wondering how this all relates to each other, to finally get the big picture.
On top of it, Wildman and Behman put a lot of "best practices" tips and advices in the book.

Soo, to sum it up in one sentence:

FINALLY an easy understandable and very readable book about debugging and compiling. If you want to get only one book about compiling and debugging, this is it !


Note: This review was edited to remove some mispellings, however you may still find some typos in the text.

Hope you will publish the contents of the Book with some workarrounds as we can be confident in ordering the book.

I'd recommend this book to any Solaris Systems Administrator/Benchmark Engineer who deals with Performance Monitoring and tuning at this job. The book goes in great technical detail about the various parameters. It is a little old (was published in 1994 when Solaris was still in 2.3) but it helps in understanding Solaris internals from a systems professional standpoint.

Brings the reader upto speed as to the issues which could affect sun systems and networks. This is a murky area and throws light on how a admin can look at each issue judicously and eliminate them one by one and get to the root cause of the problem.

For all the Sun gurus, veterans and newbies: this is for you. As a must-have in one's library, it'll be one of your most worn out references in your serious IT career. It is practical and very illustrative in its approach to solving sample problems.

Great book. I can't say enough good things about Adrian's work. This book has lots of useful information on improving performance on Solaris machines. Really good information on tuning the tcp/ip stack, however, I wish there had been more of it. If you're looking to tune Solaris, this one is a must have.

I do like this book for all things it show to us.. Especially there are treated in a very good order the way how to be connected in a few days with the most usefull commands of Unix. But, the editing joe command not exist./ however really good book..

the book is fine for people in a course studying the Unix OS. For an end user just wanting to get their feet wet it is a little advanced. I found the general information to be helpful but a little more explaination would be needed. Overall it is well laid out but too advanced.

I was one of the guys who thought that UNIX is such an operating systems that's so difficult to understand and work with as a Network OS. I even was disturbed in choosing the NOS that I should work with. Lots of people advised not to use unix because of its difficulties in understanding although its powerfull capabilities. But when I began reading this book, I knew that all of those ideas were rubbish. Although it was writen since 1992, but I guess they replaced 8 by 2 -> 1998 .. GO FOR IT.

This book teaches you UNIX in a very well organized fashion. Unlike many UNIX books that claim teaching UNIX through a light coverage of the basic commands and concepts, this book makes a balanced coverage between daily normal user needs and advanced system concepts in a very clear and understandable language.The examples are very well written and the coverage of concepts such as shell programming or the different system utilities though not very much detailed but enough to put you on track. As a reference, I keep it always beside when I get stuck in poorly written or overly detailed manpages. I don't know if this book is very well known in the UNIX community but for all whom I recommended this book, it was a great delight.

This was not the suggested text for a systems programming course I took, but thank god I used it anyway! The book is very well written in clear, easy-to-understand language (unlike the suggested text). The sample source code really clarifies the concepts he covers. I got to grips with UNIX quickly with Mr Glass' book. I would heartily recommend it to students and users.