Linux Books

I own some of Ellie's books and I've taken courses from her in Silicon Valley. She writes clearly. My main objection to her books is that too many of the examples are a bit too simplistic. Too many examples use input provided by the user at the keyboard; in the business-world/corporate world, most input is obtained by reading in a file.

I bought this book several years ago and it's safe to say that I've opened it up a minimum of once a week since then. Every single page has example code in it and content ranges from elementary to expert. gawk and sed are archaic programs with difficult to remember semantics and syntax. This book comes off the shelf every time I have to process text or files or the output of a program or any other repetitive task that is better suited for a CPU than for a human brain. The writing style is easy and pleasant without getting goofy. I highly recommend this book to anyone who uses a shell at least once a week.

I just started this book but have thumbed through all the chapters. The author is a very good writer and seems to be passionate about the subject unlike some of the authors that write dry tombs for O'Reilly. However, "Unix Power Tools", O'Reilly is not a dry tomb.

Anyway, better know your way around linux before you get this book even though it starts very basic. This is a huge book, 761 pages. Great info...

New to 'nix? You need to learn the shell to become comfortable and proficient with the OS. There is no better book for the serious beginner/intermediate self-motivated learner. Ellie Quigley is a superb instructor and writer.

I found this book very easy to understand, but if you are looking for something more advance, this is not for you. The style of writing in this book is very easy to follow. Like what is written on the title, it has lots of examples, and an explanation always comes after the example. It is not only about shell, this book also has good basic knowledge and information about grep, sed, and awk. If you use Linux, and want to learn shell programming, get this book. I also found that the examples used in this book were very close to the real life problems we often meet in Linux.

The only reason that I rate only 4 stars for this book is because some similar part gets repeated too often in this book.

This book is not good to understand TCP/IP stack in Linux. The book has not gone through review for wrong section references. I have seen references mentioning to Chapter 4 when it actually is Chapter 7.
It never explains the main processing of TCP like cwnd update and sshthresh. After reading the whole book I still didnt understand what is done in TCP like which function does what.

A complete failure to qualify as a good book.

I suggest "Understanding Linux Network Internals" which explains very clearly what is done in IP. I expect that the author of that book comes up with a second volume that deals with TCP.

Before you spend your time and money on purchasing any books on the subject, buy this one first. Depending on your background and your needs, it may also be the last one you will purchase.

At the time I got to place my two-cent's worth, there are already 5 other reviews rating this book in a very positive light.
While the style of presentation of a technical subject may not be strictly original, there have been few attempts by other authors to use it, this author has actually delivered - very effectively.

Technical writers, take a note of this work - it can serve as a blueprint for other technical subjects. Publishers, please a take note of the style and the thoroughness that this work employs to present a complex technical subject. The demand is there - the competition is very scarce.

Yes, this book presents a comprehensive technical explanation in a very practical as well as theoretical terms, and more importantly, places all the components of the technology subject matter within context. After you get through this book you will not be left in a position where you sit in front of your computer and realize you really have no idea how to apply the knowledge of the book you just read. Instead, you will be off and running. Think back, how many books that you read in the past delivered this kind of ability to you?

In closing, I appeal to the author of this book to select another subject of the current technology and write another book. Sadly, the bookshelves are full of "bibles", "primers", and definitive guides that leave the reader wondering what to do AFTER they read them.

If you need to know how to DO networking, this book is a must.

Loads of info, all's good, but it's a struggle. I mean, explanations don't match the pictures, a lot of redundancies in the text (that make you wonder if perchance they're not redundancies and force you to backtrack -- to no avail, 'cause they *are* redundancies); strange hyphenation habits ("pre-pending and removal"... well, then make it "re-moval", be consistent, at least... "pre-allocated", "de-allocated", etc.); on one line it's "sk_buff" on the next it's "skb" -- I mean THIS IS NOT POETRY! This is a lot of precise, dumb and boring literal-minded stuff that, in order to be understood, HAS TO BE RIGHT! every time, all the time). p.256, "The array of frags is placed in memory ... It can contain as many as six pages in the array." In which array? Does this mean IT ITSELF contains six pages of memory, or does mean that it happens to be in possession of yet another array -- and it is this other array that holds the aforementioned memory pages?

OK, it is an unfortunate fact of life that techies are massively deprived of the aptitude for verbal communication, fine, but where's the editor? It's a fifty-dollar book, for chrissakes. The book is very irritating in this respect.

Otoh, it's got a lot of good stuff, so, in a paroxysm of charitableness, I'll give it four stars after all. But it's darn hard to read, 'cause the author, though he knows his stuff, is an inarticulate turdhead, and the editor took a nap -- 'cause, you know, you'll buy it anyway, why bother.

Four stars, but only this time.

PS. Be sceptical about the review by John Matlock "Gunny" (right below here). This guy cannot possibly have read what he's reviewed; to convince yourself, please visit his reviews page and count the number of reviews he posts daily, every day, since the beginning of time. A dozen of all-positive reviews every day -- yeah, I believe he's read these books. Buyer beware ("Gunny" is not alone: there are quite a few "reviewers" like that on Amazon these days; when you see one of those "Top Reviewers", be sceptical, check their reviewing record; I've seen people reviewing over a hundred books per day every day; others re-type a cover blurb or table of contents; there's a lot of smart alecks of this sort, so watch out).

PPS. A couple of things I forgot to mention, but probably should have: first, there's nothing specifically embedded in this book; and second, there's a similar O'Reilly Linux networking book that is by an order of magnitude better. I didn't have it when I wrote this review (which was more than a year ago), but now I do and can compare. I forget the title off the top of my head, but search for it, it's easy to find. If I were writing a review for this book today, I'd not give it more than three stars -- though again, there's got a lot of good info in it: the book isn't bad technically, just confusingly written.

This is an excellent book which explains everything related to the TCP/IP Linux implementation in the 2.6 kernel. There are other excellent Linux networking books, but this is the best one in terms of the details for the TCP/IP implementation.

It explains in detail Network devices, drivers, UDP, TCP, IP and IPv6. And it shows in detail all the steps a packet goes through when moving from the application layer to the socket layer, then through the transport layer (TCP or UDP), Network Layer (IP) and Data Link Layer and finally to the physical layer. Then it shows the details of the flow of the packet at the receiving side.

This is an in-depth guide to implementing and using the Linux TCP/IP stack. It begins with a general overview of TCP/IP networking, with background information on applicable networking standards. From there, it details the TCP/IP implementation in Linux by following a pack of data as it flows through the stack from the sending system, out the wire, and back through the input side of the stack in the receiving machine. This unique approach gives programmers an inside look at the entire process.

The book is aimed at th engineers and programmers implementing dedicated or embedded systems including sockets, network interfaces, application protocols and practical considerations.

The CD included with the book includes the source code developed in the book, much of which can be modified to fit many quasi-standard applications, and a considerable amount of additional technical information on Linux and the particular aspects of TCP/IP.

Although slightly dated, this book is an excellent resource for wireless communcations with Linux. It also covers a lot of information about wireless computer communications in general. Want to build your own access point? The info is in this book! There are lots of ideas to build from in here!

Based on postings to user forums it seems that one area of Linux where people tend to have a lot of problems getting it to work is wireless networking. With wireless finally coming into its own over the last couple of years "Linux Unwired" is a very timely and useful book. All the aspects of wireless in all of its current manifestations are covered including Wi-Fi (Wireless Fidelity), Bluetooth, infrared, cellular networking, and global positioning system (GPS) devices.

Before getting into the details of getting Linux to work with wireless the authors provide a thorough understanding of radio waves and how they act, hardware, and antenna types. Understanding these basic concepts is important if your system is to work the way you want.

One of the really nice features of the book is the information on picking the right card so you have the fewest problems getting things up and running. The authors even name specific manufacturers and card models that work well with Linux and then they go through installing the driver and configuring the software to work with the device. Along the same lines they provide information on Linux friendly access point providers and even building your own access point.

One you have your Linux system up and running on wireless there is a chapter on locating hotspots and using them to get onto the Internet. This chapter really only covers the basics of locating hotspots. If you are really interested in this area you might try another O'Reilly book just on this subject titled "WarDriving, Drive, Detect, Defend". Of course, if you are concerned about your wireless security (and you should be) it includes information on configuring Wired Equivalency Protocol (WEP) and Wireless Protected Access (WPA).

If you are anticipating moving your Linux system to a wireless interface you can't go wrong with "Linux Unwired". The authors do an excellent job of providing all the information you need to get it done right. "Linux Unwired" is highly recommended for anyone interested in Linux wireless networks.

I didn't even originally realize this book had a chapter on cellular data until I found Brian Jepson's site, Jepstone.net, and began reading about using cellular phones and PCMCIA modem cards. This book's cellular chapter was just what the doctor ordered! There are instructions for Verizon, AT&T, Cingular and T-mobile, that make things more manageable even for advanced Linux users. Way to go, guys!

I was impressed with this book. It's short and focused. It strays a little on the non 802.11 chapters, but that seems to be the way with all of the O'Reilly wireless books. Here is the blow by blow:

Chapter one is WiFi basics, it's short and solid. Chapter two is about the hardware and it's quite in depth in terms of getting the interface card installed and configured. Chapter three is about connecting to the network it's a little short and basic, some more effort could have been spent there. Chapters five and six are about the server side of the equation. Chapter six is a bit long, it's about building the server and covers the entire setup from hardware to software configuration. Chapters seven through nine are about non 802.11 networking through bluetooth, infrared and cellular. These chapters are a little skimpy and graphics heavy, but you probably won't be getting the book for them. Chapter ten is a brief introduction to GPS.

I would recommend this book to anyone with issues around Linux wireless network. Linux documentation can be a morass and it's worth your time and money to plunk down a book that walks you through the process.

This is a valuable book for two reasons.

First of all, and most significantly for a Linux book, it's hard to get a handle on the subject from the free information available on the web. I'm sure all of the information in this book is out there, but it's scattered far and wide, and this book is clearly a big time saver.

Second of all, the authors know their subject inside and out, and they have organized it pretty well. I have an Orinoco card, and the explanations of the differences in the various drivers for the card have been extremely helpful to me. Some drivers will let you scan for wireless networks, and others won't -- that's the sort of thing that would burn hours and hours of troubleshooting time, but it's all explained clearly here.

I bought this book so I could get a wireless connection going on a Linux From Scratch laptop, but after reading the book, I'd like to build my own access point with Linux.

George Reese's MY SQL POCKET REFERENCE 2ND EDITION covers Version 5.1 and provides SQL statements, functions, and insights into its variations and utilities. Explanations are accompanied by tables and examples for maximum efficiency.

MySQL has gained a lot of functionality after this book was done, but if you are a infrequent developer and like to have a quick reference into basic MySQL functions this book is great.

Very practical and after every command there is a very useful example.

Reese hits a solid triple to start the inning off and scores easily on the wild pitch thrown by the reader who says that the GRANT section is wrong. This book works easily and appropriately at your deskside. I found the book to be a very simple, easy-to-navigate reference text that presents the most important aspects of MySQL in the quickest, most logical manner. It is very easy to thumb through with every possible random page landing at a topic of interest. In a way, it was like working with a familiar dictionary, you know the kind, where you just kind of naturally crack it open near the word you're accessing and flip a couple of pages either direction to arrive at the exact reference location. In that vein, I'd perhaps recommend that the margins contain "bread crumbs" telling us where we are in the book, but it isn't necessary since thicker sections often obviate themselves with just another page turn. Each page does have the chapter title in the margin, so my point is really one of nit-pickieness rather than a true critique. To its credit, the layout of the book presents the content in a manner that follows the O'Reilly "risen bar" standard. It is easy to scan through the entire reference flipping pages as quickly as possible so that you are able to arrive at your sought information within as much as a second or two. The bold text draws your eye to the page and the size of the page allows one to capture everything in a single glance. In my usage of the book, I found it very accurate and useful. I am a regular MySQL user and the formatting is very familiar to me. I highly recommend this book. If you are already familiar with SQL and the basics of database schema design, this is the perfect reference. I found it amazingly faster than loading the MySQL PDF manual and searching through potentially dozens of hits for the keywords sought. Even at the full cover price, this book is a value-added service at my side. The sections on operators, functions, stored procedures and triggers make this book an invaluable tool for the DBA or programmer who knows the material, but fails to remember every single aspect about the syntax AND who is tired of seeing that familiar: "You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near..." The text also finds welcomed complement from the numerous examples of using commands and SQL keywords. They are invaluable for immediately deciphering the sometimes too-numerous options of a command. I don't know that the book has taught me anything new at this point, but it certainly makes finding the details of what I already know much easier. Because of its brevity and its ease-of-use, it has made me want to play around with some of the various features of MySQL that I do not regularly use. That alone is going to teach me something new sooner or later! If your budget is constrained to a single reference item on MySQL, you can't go wrong with this very portable pocket reference. The back cover says: "When you reach a sticking point, but have to get to a solution quickly, MySQL Pocket Reference is the book you need." I agree completely.

It's handy, but a little old and too brief with important parts left out. It needs to be updated and improved. Ie: The admin commands are poorly covered. Do not use this book to help you use Grant or Revoke. The Grant All section is simply wrong.

The book was very good. It told Linux in plain English no computer talk! I loved this book!

When they say "No B.S.", they really mean it. I bought this book and read it in two days. I can now do anything from install Linux, setup Linux, read my mail, navigate the system, compress files, and do just about anything else I may need to do. Although I recommend getting another book to go with it, this book really taught me the basics "without the fluff".

I have lots of books on Unix and Bob's guide to Linux is one of the few that I turn to frequently. Recommended for people considering to move to the best free Unix on the planet!

This book is one of the best Linux books I have read. Everything is written for the beginner. I have been using Linux for 14 months and I wish I had this book when I started out. If there is anything bad about this book, it is that it comes with Linux Pro 4.1. I recomend you go to linuxmall.com or linux.org and buy a copy of Mandrake Linux 5.3 or Red Hat Linux 5.2. Overall, A GREAT FIRST LINUX BOOK!!!!!!

I picked up the book when I was still flailing around with Red Hat 5.2 and its user's manual, having little idea of the basic concepts involved with Linux. It was a veritable lifesaver. Not only is it accessible to a vast majority of readers in its writing style, it provides all the basic concepts needed to become familiar with Linux in relatively short order. One great example is its introduction of the tar command...when I went to newsgroups for help, I always got the 'man tar' response, i.e., no response at all. The tar manpage is a good example of too much information, and all I wanted to do was unpack a file! The book gave a few examples of the most commonly-used options for tar, and good combinations for each. It got me up on my feet and running in less than 4 days. One of the disadvantages to the book is that it comes with a distribution called "LinuxPro." The default kernel they use is 1.3.10, I think...youch! The other packages are similarly older. However, the documentation gives a decent "tab-A-into-slot-B" coverage for compiling a new kernel; it even includes the sources for 2.0.27. That was my first kernel compile. Overall, this book is the best choice for a beginning Linux user, providing a thorough introduction without all the "fluff," exactly as advertised. I hope to be able to review his new "No-BS guide to Red Hat 6" soon as well.

This book covers everything a professional Linux developer needs to know about GNOME development. While it may be unlikely that many developers will need to use GTK+ in C extensively, understanding the design at that level will allow you to understand the architecture of high level GTK bindings such as PyGTK.

I strongly recommend anyone that intends to code against GNOME to read this book. It introduces concepts in a very succinct and natural way.

Pros: The book covers everything you need to get started on OSS/GNOME development. Assuming you are already a skilled programmer... The book is very terse and to the point. Examples are useful and compile. Explanations are thorough and accurate. If you are a nerd you will find this book teaches you a lot.

Cons: Book is somewhat terse, and in places hard to read. In it's defense, some of the material it covers is very complex (and if you find yourself bored to tears - skip a few pages and come back when you need it...). You need a very thorough understanding of the C language for this book to be useful to you - which is understandable as GTK+ makes very advanced use of the C language. If you are not a nerd you will find this book a cryptic list of nonsense.

Another reviewer mentioned this was a very "jargon filled" book -- it is. On the other hand, this book is going to teach you GTK+ well enough that you could go read the source and potentially submit patches to the libraries. This level of detail requires accurate and specific terminology.

The book is translated from German. It is a credit to the translator that this is completely unnoticeable while reading the text.

This is a very clean and readable book introducing Gnome/Gtk2/GLib2 application developpement and can be also used for understanding GLib2 C utilities (strings, hashes, arrays, lists, trees...) and Gtk2 (treeview wigets, etc..). It also adds the Gconf stuff (an api for storing your app's configuration).

But unfortunately, neither the Bonobo graphical components nor the Corba services are presented. So, after reading the book, you still cannot know how to make your program communicate and integrate with other Gnome de facto standard apps. I hope some people will add one chatper or two about that in the next version..

This is a pretty heavy duty programming book. The opening words say you should have, "Firm Programming Experience in C, including pointers, dynamically allocated data structures, and pointers to functions, C macros and the C preprocessor, fundamental understanding of Unix: processes, libraries, search paths, and so on."

Then the first chapter is on GLIB, a description of the more popular of the routines included in the library. The second chapter, GOBJECT has an opening note: "This chapter is dry and dense." -- Still, this chapter is one of the best descriptions of object oriented programming that I've ever read.

Finally in chapter 3 you begin to get into the heart of the matter. GTK+ is the toolkit for programming the GUI. Chapter 4 is on the GNOME Libraries. These two chapters are really the heart of the book and runs for about forty percent of the entire book. After that there is just some odds and ends that are left over.

This book, as clearly and succinctly as possible does what it sets out to do. It's not the simplest book on the shelf, but then again, neither is its subject.

I'm more of a command line kind of guy, but there are things better done in a graphical treatment. When this is true, I often resort to HTML, but that isn't always suitable either. Most of what I've read about GUI programming has left me feeling daunted by the learning curve, and the writing itself has mostly been difficult to read and unsatisfying

This book was a delightful exception. As its introduction promises, the content "lies somewhere between a tutorial and a reference". The code examples are often just the kind of things you would write yourself to test-drive your understanding; no unnecessary fluff. There are complete programs also, and these are downloadable from the No Starch web site.

Matthias Warkus has a real knack for explaining complex subjects. I particularly liked his way of explaining object inheritance, which is completely upside down from the way it is usually presented, and thereby makes a much more understandable case for using OO code.

The first chapter is an overview of GLib capabilies. I was quite surprised at the things GLib includes: I come from the days when you needed to buy commercial libraries to get features like memory management, linked lists, B-trees, etc. The second chapter covers GObject, which adds Object Oriented capability to standard C programming. That's an important aspect of Gnome: it is plain vanilla C with the OO stuff added on through the GObject library. For those of us who have yet to be entranced by C++, that's important.

Chapters three and four explain GTK+ and the Gnome libraries, the overlap between them, and hen you'd use either. Chapter five is a lucid introduction to Glade, the interactive development tool for Gnome. I was interested to note that Glade produces XML files that your programs references through calls to Glade libraries.

The rest of the book is miscellaneous coverage that wasn't covered elsewhere; compiling issues, configuration helpers like Gconf. I had ben previously unaware of the GnomeVFS discussed in chapter eight which allows your program to transparently access remote web servers and archive formats like PKzipped files.

All in all, this looks like a very good intro to Gnome GUI development.

As the author already states in the introduction the book doesn't cover all the aspects of gtk and gnome, because then the book would be over 1000 pages, but with what it covers it covers very well and you can have a great start with gnome programming.

The rest you can probably find out from the online documentation or the author has to write a part II

I found this to be a good book. It was a quick and easy read, I read the whole thing in about a week. The subject matter was a bit simpler then I had expected, yet it filled in some of the basic details that the more advanced books just skip over. This is was a great book for beginning unix shell scripting.

My first impression of "Oracle Shell Scripting" was not a good one. After looking for the download site for the scripts in the book I was frustrated. The first chapters seemed a little rudimentary. This book is not a learn how to script book. The first five chapters give a scripting refresher. If you have no experience with korn, or bash scripting this is not the book to start with. If you have used Oracle on UNIX/Linux this books puts all those nuggets you have gathered over the years and some you have missed in one place. This book has scripts that you use in every day DBA work. This book deals with Oracle, sqlplus and UNIX/Linux scripting. I bought this book to help me transition from korn scripting in Solaris UNIX to bash scripting in Linux. I consider it worth the investment. Caution avoid the frustration of looking for the script download website. It is not in the book. You have to email the author to get the site. There is not enough information on using scripting with Oracle Application Server.

A well written book. A great way to learn shell scripting. Relevant and useful examples throughout the book (downloadable code).

This book has helped me impress my colleagues and boss..I originally browsed through it at Border's (and found myself sitting on the ground with a notepad scrambling to copy as much as possible)..of course, then I realized I had to have it, so I bought it online..I knew the publisher was a trustworthy source because I'm always using Don Burleson's DBA tips online.. this author's approach is easy-to-follow and concise; yet it's a thorough guide that is like a catalyst for your own creativity...it has made me look forward to extracting the power of the shell.

It's a lot better than parsing through thick UNIX encyclopedias or cycling through fragmented online material..as an OCP 10g/9i DBA, I still feel like there are not enough practical day-to-day guides like this one for junior/mid/senior-level administrators, since over half our work is directly/indirectly connected to the shell.

Oracle administrators of all levels will find benefit in this book. The author has put together the basics in shell scripting and OS fundamentals in aid of maintaining and monitoring scalable production Oracle environments. Each example is easy to read and follow and leaves the reader with room to explore and extrapolate on their own with little effort. A great lookup source for old timers and "must have" for newbies,


I highly recommend this book
-Rat

Of the books that deal specifically with Nagios, this is a good one. It goes into greater depth on topics the product documentation doesn't, such as passive checks. On other topics it makes a good companion to the documentation, providing additional examples and alternate explanations.

Only down sides are several typos, and that Nagios v3.0 is nearly ready for release! So I can only hope these authors are encouraged enough to do a second edition when that happens.

I recently received review copies of Pro Nagios 2.0 (PN2) by James Turnbull and Nagios: System and Network Monitoring (NSANM) by Wolfgang Barth. I read PN2 first, then NSANM. Both are excellent books, but I expect potential readers want to know which is best for them. The following is a radical simplification, and I could honestly recommend readers buy either (or both) books. If you are completely new to Nagios and want a very well-organized introduction, I recommend PN2. If you are somewhat familiar with Nagios and want detailed descriptions of a wide variety of Nagios plug-ins, I recommend NSANM.

PN2 is an extremely well-written book. James Turnbull's style is very easy to understand and his message is well thought-out. One of my favorite aspects of PN2 is the author's multiple recommendations. He doesn't just explain options and features; he says what he thinks works best. Turnbull's syntax examples are very helpful and thorough.

I found PN2's approach to be just what I expected and needed. A basic Nagios user could read the first five chapters (Installation, Basic Object Configuration, Security and Administration, Using the Web Console, and Monitoring Hosts and Services) and have a working, capable Nagios installation. The last five chapters (Advanced Commands, Advanced Object Configuration, Distributing Monitoring, Redundancy, and Failover, Integration Nagios, and Developing Plug-ins) address more advanced topics.

I was particularly glad to see security addressed as an important topic. I liked his explanation of why not to use .htaccess files with Apache (p 92-93). PN2 also introduces working solutions for redundancy and failover (topics not explicitly covered in NSANM). The author takes steps to ensure readers really understand Nagios; for example, he explains macros well, while NSANM mentions them without much thought.

I did not encounter any real technical problems with PN2, hence its high rating. I saw the author mention TCP as the transport protocol for SNMP on p 181; it should be UDP.

PN2 is an ideal book for anyone who wants to run Nagios. I believe new Nagios readers should read PN2, and strongly consider NSANM as a complementary reference volume.

This book is great as an introductory book for Nagios. Although it doesn't cover some advanced functionalities of Nagios in depth, it tells you enough to know about them and research more.

It takes you step by step to configuring your Nagios the right way, and exploring all of it's many features along the way. I bought this book to start with Nagios, and it has succeeded to completely fulfill my expectations.

There are good checkpoints on the end of each chapter, which is a nice touch.

What I liked the most myself, is that author has put in "best practices" to show you not only how to do things, but also how to do them the way they should be done, which is what I expect to get out of a good book.

A very good introduction to Nagios. V. thorough and detailed. I would have liked more detail on monitoring SNMP devices and server monitoring especially gathering stats from HP servers with Compaq (HP) agents installed but this may be too specialised for this book. Basic Windows server monitoring is covered. Highly recommended for Nagios novices.

Nagios is an open-source software tool that constantly monitors your system and provides feedback when it appears that there may be a problem. Nagios is a Linux based product that allows the administrator to track a wide variety of hosts, systems, services, and just about anything else they would want to know about. Completely configurable, the administrator sets thresholds and the system creates and alert any time this threshold is met. The beauty of this sort of system is that it allows the administrator to be notified of potential problems before they become major problems.

Even the notification method is configurable as it will email a message, create and instant message, use SMS paging, text messaging, etc. Once you are notified if you want to check on the system you can enter the web interface and view the current network status, notifications, problem history, log files, etc.

As is often the case with open-source applications, the product is fantastic but the documentation not quite up to par. That is where this particular book comes in handy. The author goes through all the details of setting up a Nagios server from the beginning decisions of just where to place the server to the set up of individual objects, notifications, groups, permissions and exactly how to check services and objects. He even goes so far as to discuss how to integrate Nagios into other products such as Snort and developing and writing and plug-ins.

Written in a style that is easy to follow for the average Linux user who is comfortable with the Linux filesystem, editing configuration files, and generally working with the command line. This is not for the new user familiar only with the graphical desktop environment. But for the Linux system administrator with an intermediate level or higher skill set Pro Nagios 2.0 is an excellent resource and is highly recommended.

Need Samba? Have a deadline, but find yourself intimidated by the intricacies of Linux? If that is the scenario you face, then Samba Essentials for Windows Administrators has been written with you in mind. Here the author begins with a comparison of the Windows platform and the Linux kernel, outlining their similarities and differences, providing a sense of direction to newbies. Taken as a whole, this book provides a good jumping-off point into the larger world of Linux.

Samba is approached in very task-oriented chapters. After an essential look at the basics of Samba, the chapters are broken down by task. Need a file server? Consult Chapter 3. How do I configure my Windows machines? Take a look at Chapter 6. Probably the best quality this book features is its coverage of SWAT, a powerful web interface that configures Samba in a way quite reminescent of Windows. Hence the title. You'll go from zero to Samba fast.

And yet, while this book is a worthy resource, I noticed one drawback. I highly recommend this book, but also suggest that it be used as a companion to other resources, including the official documentation on the Samba website. I bought the hard-copy version of 'Samba 3 by Example' (Terpstra), and together these two books helped me get up and running. The essentials are of course - essential - but on your way you'll come across a few snags. Sometimes these fall outside of the essentials, so you'll need a comrehensive grasp of this technology.

Very Very Good Book!! Beyond Excellent!! Beyond 500 stars!! I am very new to Linux and this book made it a breeze to get Samba running. Very refreshing to see such a useful reference tool available for the Linux community.

I am a Windows admin wanting to set up some easily managable Samba servers to complement the current setup. I find that this book doesn't baby me but explains how to get the tasks i know I want to do, done. However I am a little disappointed that the section on Winbind is a bit brief and left me a little confused.

This book is relatively well written and well thought out.
IT contains usefull samba information. Here is what I didn't like.
I felt like half the book is dedicated to setting up interfaces to configure and maintain samba, ie SWAT and Webmin. WASTE OF TIME!!!! There are plenty of more in depth issues that I felt this book didn't cover in greater depth. I was recently in a situation where I had to integrade a Windows 98, Windows 2000,NT 4.0 and AS/400 clients with a SCO Unix Server. There were many authentication issues related to Windows 2000 that the book didn't cover. If you are a windows admin and you like flashy interfaces and you are just looking to set up simple file sharing between Unix and smb clients. Then get this book. It will help you do that. However, I don't think the text delves deeply enough into the integration challenges that Unix/NT admins face everyday. Overall a good book. But too much focus on web tools and not enough on scenario planning and architecture. Another problem with this focus is alot of people understand the classic unix approach.
The /etc/smb.conf file is very straight forward and self referencing. I find it much easier to deal with that file and not have to worry about all sorts of flashy stuff that take the focus away from the task at hand.
Making windows clients happy.

Only a 3. This book has some interesting topics about it, most has to do with Administering a Samba Server from the Web. Not from a Prompt. I was looking for more of a "Tricks of the Trade" kind of book. But this one does have some good points to it about web administering. But, what happens when the web is broke?
You are going to SSH into the box and fix it from a prompt not from a Web Page. Otherwise this book IS GOOD but not GREAT!

While the Bourne shell is listed as a full fledged programming language, few people use it like that. Some of it is that they prefer more commonly acknowledged languages like Perl, Python or the like. However, with a book like Shell Scripting Recipes: A Problem-Solution Approach, they'll want to thin twice about it.

I remember my first forays into shell scripting. I didn't want to learn Perl (then the clearly dominant scripting language), and worked hard to learn shell, awk, and sed so that I could do the things I needed to do and automate as much as possible. It paid off, and even impressed a few die hard Perl fans. Less code to do simple tasks, faster to write, and always present. While I don't do nearly as much shell scripting as I used to, I still enjoy seeing someone do neat things in /bin/sh, ksh, or bash.

Chris Johnson's book is in the traditional line of a reference book, much like the O'Reilly cookbook series or, more accurately, the old tome, UNIX Power Tools. It's got a couple of non-recipe chapters, and the rest of it is a lot of fun, useful shell scripting.

Chapter 1 is an invaluable reference to large portions of the POSIX shell language. Johnson covers things like built in commands and program flow, special variables, and variable expansion. He also clearly covers the differences between the Bourne shell and the POSIX shell where they differ. If you're worried, using Bash will almost always work with the examples, I think.

At this point it's easy to think, "I can call out to external commands for a good chunk of the functions he develops." You can, but Johnson makes a compelling argument that shows the impact of a fraction of a second can add up quickly in loops. At this point, you're either agreeing with him and seeing the joy of a direct language like shell or you soon will.

Chapter 20 is a small set of recipes but they serve a different function, namely helping you manage all of these new shell scripts and functions. You can copy, instantiate new shell scripts more easily (by automating the redundant bits), or package them up with simple scripts. Handy tools, and a decent approach.

The recipes run the gamut from the simple to the uncommon, but they all illustrate how do accomplish useful tasks in a shell script. They include file conversion (DOS, UNIX, and Mac), string handling bits, filename management, complex date calculations, screen control capabilities, and even HTML processing. Some of my favorite recipes include the Postscript generation tools (!) and the database management tools. While some people have done these in shell scripts, I've usually seen them done using sloppy or confusing approaches. Johnson's code is clear, direct, and applicable.

That's probably the biggest strength to the book, Johnson's clear writing and examples. Some programming and scripting books try and show you neat tools to accomplish a task, but they don't do a good job of showing you how to translate it to your specific task. In Shell Scripting Recipes, Johnson chooses his code carefully, articulates how it works, and continually builds on a theme. If you pick a few scripts and study them, you'll see tips and tools you can use in your own shell scripts. He also has nicely abstracted scripts that let you recycle his functions in your own scripts with ease.

Overall I quite like Shell Scripting Recipes, I think that while it's easy to think less of the Bourne shell as a language, Johnson has done a good job of writing a concise set of examples, usable code, and in a format that is continually useful and clear. If you've been thinking about improving your shell prowess, this is the book for you.

Useful. Good examples (but not for the absolute beginner). Korn shell users might want to also consider "Korn Shell: Programs for Your Survival at Work" by Larry L. Smith. Bash users might want to consider "Bash Shell: Programs for Your Survival at Work."

If you are using a Bourne-type shell, and BASH in particular then you will find a lot of valuable information in this book. Author Chris F. A. Johnson provides an extensive education on scripting including scripts for viewing, editing, and manipulating files, manipulating strings, altering the path variable, monitoring the file system, filtering spam, backing up, archiving, deleting, and many other common tasks. How far can you go with a shell script? He even gives a working example of a database application written completely in script. On the other hand if you just want to have some fun there are even scripts for creating anagrams, fitting words into a crossword, or finding words that contain a given set of characters.

While the book is really written for the technically oriented reader, even the very basics that most users should already know are still covered. The format is more typical of what computer technicians want - this is the item to be discussed, this is how it works, this is an example, move on to the next one. When I am looking for answers this is the format I prefer and I found this book extremely useful. It will be on my bookshelf as one of the first to grab when I want to do scripting in Linux. Advanced and powerful, a real resource for the power user of the Bourne shell, Shell Scripting Recipes is highly recommended.

This book was kind of an epiphany for me. I've been writing shell scripts for nearly as long as I've been writing programs, but I've always drawn a mental distinction between the two. There was programming, and then there was scripting.

After coding in languages like Perl and then Ruby, the distinction has become increasingly blurred. Many of my "scripts" have proven far, far more useful than anything I've written in a "proper" programming language! They back up my servers, they keep me informed of problems, they've saved me a minute here, a minute there, for perhaps ten years now! So what, really, is the distinction?

I think, to some extent, a shell script is ultimately just limited by a lack of any libraries of code. It lends itself well to simple tasks, but if you do anything even moderately complex, you have to stop and switch to Perl or Ruby. But now Mr. Johnson has written a book that more or less creates a library in your shell script. And the tasks he writes about are so incredibly common, and his recipes so well organized, that you can just flip to a chapter like "Backing Up the Drive" or "Good Housekeeping," and find a dozen solutions to questions you're guaranteed to run into when writing your shell scripts. This book also does an excellent job of showing examples that rely on as few external programs as possible - making them perfectly portable.

This is the most useful book on shell scripting out there, and I wish I could have picked it up ten years ago. If I had, it would still be on my shelf today.

Shell Scripting Recipes provides the reader with a handy reference for shell tasks that range from the common (how do I extract a portion of a string?) to the complex but sometimes entertaining (find words that fit together on a grid aka make your own crossword). The author does a great job in his layout by presenting the problem, listing the solution and then explaining how it works. The script solutions and examples are broken down by topic and each chapter is indexed on the side of the book for easy reference by the reader.

The book was written for those who have had some Unix/Linux experience under their belt and now want to explore some of the power of the shell itself. Seasoned BASH shell users know that one of the most powerful aspects of the system is the ability to create applications that perform necessary tasks or functions just by using shell scripting. This book would be ideal for anyone who wants to get more out of their system that just using the GUI-interface that has become so common.

Most of all, it covers a lot of problems that occur everyday and that we sometime spend hours looking for a solution for. Things such as removing excess linefeeds from a file, reformatting text, retrieving data automatically and other related tasks -- things that shell scripting excels at providing a mechanism to solve.

Not for the beginner, but a must-have for the experienced Unix (particularly BASH shell) user.