Customer Reviews

UNIX Shells by Example with CDROM

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

 

 

If want to learn about shells and you learn by example, like I do, this book is essential.

The first 6 chapters (nearly 200 pages) goes over the basics of all shells; what they are, what they do, what programs are most used to manipulate data in them. There are whole chapters devoted to grep, sed and awk, and the author doesn't skimp on details. You will be a virtual grep/sed/awk guru by the time you learn everything in these chapters.

Chapters 7-15 introduce and get you into scripting of each major shell: Bourne shell, C and TC Shells, Korn shell, and Bash (bash is the standard shell in most linux distributions). It then spends a chapter on general debugging shell scripting problems.

The last chapters touch upon system administrating via the shell (rather than using gui tools). Again taught by example so it's very clear to the reader.

I learned more about bash (my shell of choice) from this guide than any other that I've read, and not for lack of trying, I've read several bash guides. I was happy to see that examples given were explained line-by-line so you don't lose track of what is happening in each example. I was delighted by the useful appendices covering useful commands and giving side by side shell comparisons.

This is my favorite shell book to date.

The 'Unix Shells By Example' is a well-known book in the field of shellscripting. It has about 640 pages with a CD-ROM included. The book is well edited, with good white-spacing and clarity in layout. Having taught the unix shells for over 15 years, the author really knows her stuff, and the text is factual and to the point.The index seems complete and one doesn't have a difficulty in finding the right info one is looking for. These properties should be normal for books, but computer books seem often an exception.

The chapters deal about the central unix-commands for scripting (Grep, AWK,SED) and the big three shells (korn, bourne and C-shell). The author explains the subject in great detail by showing examplescripts. First you're given the data or text to be edited, then the script or commandlines and finally a lenghty line-by-line explanation of the scriptsyntax. The subjects of the scripts range from explaining the basic unix-commands to complex intertwining regular expressions, functions, obscure nawk options etc. The author also touches the subject of shell-history, making comparisons of the three shells, giving 'lab-exercises' and some unix background about commandtypes,login and inheritance. The apparent subject that is missing in this book is the Bash shell, the preferred shell in the Linux community. However, a seperate book on this subject is available (Linux Shells By Example). As with all books that have an extensive coverage of the subject, this book too can be overwhelming for the absolute beginners in shellscripting. It takes some time before one writes sytax like:

nawk -F: 'BEGIN{printf("What vendor to check?");\

getline ven <"/dev/tty"};$1 ~ ven\

{print"Found" ven "on record no" NR}' vendor

Instead of searching the pages for the basics, beginners should consider buying an entrylevel book. Conclusion: For the intermediate scripter who visits shellsites like shelldorado and lurks newsgroups in search of advanced programming constructs to steal this book is a great find. You won't be left with a feeling that you'll outgrow this book. For newcomers in scripting this should however not be the first book to buy, they're better of with titles like "learning shellscripting in 24 hours". But once through these 24 hours, this book can only be warmly recommended.

Several of my fellow system engineers bought this book and they loved it. I purchased this book about three weeks ago and I have not put this book down! There are still several typos in the examples, but, like all programmers and engineers know, debugging is part of the job. In all honesty, fixing and tweaking the examples is actually fun. I strongly recommend creating the labs at the end of the chapter. These exercises will solidify your knowledge.

(This is a review of the 4th edition)

As I start playing around more with Linux, I'd like to get into some shell programming. After reviewing Unix Shells By Example (4th Edition) by Ellie Quigley (Prentice-Hall), I think I've found the book I need to get started.

Chapter List: Introduction to UNIX/Linux Shells; Shell Programming QuickStart; Regular Expressions and Pattern Matching; The grep Family; sed, The Streamlined Editor; The awk Utility; The Interactive Bourne Shell; Programming The Bourne Shell; The Interactive C And TC Shells; Programming The C And TC Shells; The Interactive Korn Shell; Programming The Korn Shell; The Interactive Bash Shell; Programming The Bash Shell; Debugging Shell Scripts; The System Administrator And The Shell; Useful UNIX/Linux Utilities For Shell Programmers; Comparison Of The Shells; Index

I know that there are a number of different shell scripting platforms, but I really don't know enough to understand what is different between them. In a single book, Quigley covers all the options so I can start to make some decisions about what direction I'd like to go in. And regardless of whatever choice that might be, she covers all the different platforms in equal depth so I don't have to go out and buy another book to get started. Each chapter is filled with a number of examples, immediately followed by an explanation of how the example works. So not only do you have the benefit of reference material on how something like the grep utility works, but you also have the benefit of seeing working examples in order to translate theory into practical knowledge. Her style of writing is clear and concise, and I really think that with a little time on my part, this book will take me well down the road to where I want to be.

An excellent choice if you're looking to get into command line scripting of your UNIX or Linux systems...

This book was a brilliant concept with a horrible execution. It is filled with typographical and substantive errors. In the first chapter alone (I have the 3rd edition) there are examples that are simply wrong (chsh command and /etc/shell[s] file on page 3), incomprehensible (Figure 1.8 on page 18), incorrectly marked (section 1.4.4 on page 15), incomplete (Example 1.6 on page 16-17), or confusingly repetitive (explanation of pipes on page 19). Then the book suddenly presents a script written for 3 different shells, using a bunch of commands that are only vaguely explained. These explanations and descriptions of the scripts do not always match the source code, which is also different in the book and on the CD. And to top it all off the supplied source code on the CD is numbered incorrectly! For example the shell scripts for chapter 11 are located in the chapter 13 directory on the CD!

The errors continue. In chapter 2 on page 32 the regular expression examples contain several typos that made a difficult subject almost impossible to understand. The chapters on shell programming alternate from being incomprehensible to superficial. The author can not seem to decide if the book is a reference, a book of examples, or a book to teach and explain shell scripting. In trying to write a book that is simultaneously all three she winds up achieving none of these adequately. The index is lousy, and often incorrect. I had to look to other books and sources to straighten myself out. I strongly recommend that users of this book buy or borrow several other books on Unix and Shell Scripting to help make sense of this mess.

A fully corrected and thoroughly edited version of this book could be a masterpiece. (An errata sheet would not be enough as there are too many corrections to make and that would make the examples even harder to read and understand.) But as it is this book is worse than useless. None of the information in it can be trusted without cross-checking and testing.

I have been working with shells since about 5 years, and besides the "man" pages, this book has been the only one I ever used when writing shell scripts.

I rarely comment on books, but I really felt this one needs my appreciation.

The highlights of this book in my opinion are:
- a large and very well index--it really helps you finding your answer quickly
- very good introduction to shells and environments
- very good introduction to regular expressions
- very good introductions to the very important utilities grep, sed, and awk
- detailed sections with many examples for interactive usage of shells as well as programming shell scripts

For many people the sections on the c shell, korn shell and TC shell may seem unnecessary, since (I assume) the majority is using the bash shell. However, some things in those sections apply to the bash shell as well, and besides that one never knows which shell one has to work with one day--so by having it all in one book, you should be set.

Last but not least I would like to add that there is no need for reading this book from start to finish, you can just jumpt right into any section, as I have always done ;)

Get this book if you want a great all-round book on shells, and should you still get stuck, type "man ..."

This book is probably the best book to take up shelf space in your cube if you use sed, awk, and grep with shell programming on a day to day basis. The format of this book is awesome, the examples are more often than not extremely useful, and it uses a style that other books should definately borrow. As a guru that writes manuals too, I have to say that this is exactly the kind of book that a knowledgable user should own. I think what most of the typo watchers out there are really afraid of is that the understanding a book like this provides to the topics discussed, will make these so called 'gurus' more mainstream and force them to actually develop some people skills. Quit whining about the typing, its the best book for understanding Unix programming there is.

Unix Shells by Example is my sixth UNIX-based programming book. And certainly the BEST of all. DOS-like Command-line oriented interface has been my favorite over windows for obvious reasons... I have been working with them since the days of Wordperfect5 (wp5) for DOS; ... way before the introduction of Windows 3.1. Since then, I have gone through several batch scripting/programming books. Now transitioning to the world of Linux/Unix, I was disappointed by all the shell programming books that I have used so far before coming across Ellie Quigley?s book. It was so good that 3 of my colleagues ordered a copy each (a new 3rd edition).

Pros: Provides a step-by-step on how-to accomplish a real-world task with a sample code. Plus a concise & straight forward narrative/explanation of every line or special character used in the examples. Before reading this book, I have used many Unix symbols without knowing the reasons behind their use or alternate options. Other books have always provided a generalized answer of "it is the standard procedure". Such as "#!/bin/ksh"
Also, it provides comparison between various flavors/versions of unix shells. So whether you are cranking out a new shell script or you inherited a some with your legacy system, be it in Csh, Sh, bash, or my favorite 'ksh'; be rest assured that help can be found within the pages of the book.

Cons: the author could have provide more than one scenario for each of the examples.

I own several of Ellie's books and have taken classes from her in Silicon Valley. The books are clear, the index is excellent, but the examples are too simple. For example, many examples use input typed in from the keyboard (instead of reading in input from a file). Business applications/corporate applications usually read in input from a file.

Clear, thorough, well written and the author has made the book very readable.

I find this book as a excellent introduction to most popular shells and environments, regular expressions and to the very important utilities grep, sed, and awk.

All this stuff in one place makes it a great reference.

Highly recommend this book.