Rating: 
Summary: excellent
Review: If you've done any intoductory shell programming at all, this book will get you started in more serious shell programming efforts. I only gave this book 4 stars although it really deserves more, because it may not live up to the expectations of some readers.Only the Bourne shell is covered, because it's the most portable. It covers all the basics and many advanced issues. The authors philosphy is to teach by example, and this book is full of examples and sample code. The first half of the book is a down and dirty "How To by Example." The examples are general enough and well enough documented that the use for the syntaxes described remains clear in the readers mind. The second half of the book contains some sample shell utilities. These are shell programs that were written to mimmick or epxpand on functionality of common UNIX commands. I found the first half of the book to be the most useful over time. Some explanations may be a bit terse for brand new shell prgrammers. Awk is covered in much detail at all, although there are some very nice examples of using sed. All in all this is the best shell programming reference I've seen.
Rating: 
Summary: Extremely Efficient
Review: Like a good programmer, Bruce Blinn writes his book very efficiently. He describes the command briefly
then uses well-thoughtout examples to show the power of that command and the 'gotchas'. He groups the
commands and points out differences between similar tools (like single v double quotes v brackets )
He also textually hyperlinks you to other chapters in the book for further reference when a subject is referenced
but not covered at that time. While the book is only about 250 pages (including 5 blank pages for your own notes), Bruce covers all the
good stuff. If you want the info, get it here. If you more words for your money, there are other books for that. For the gentleman who asked about Chapters -
Chap 1 Shell Syntax
Chap 2 Shell Variables
Chap 3 Shell Functions & Built-in Commands
Chap 4 Using Files
Chap 5 The Environment
Chap 6 Parsing Command-Line Parameters
Chap 7 Using Filters [sed, awk, ed. Get O'Reillys Sed & Awk]
Chap 8 Shell Utilities [Arith, String, UserInput, etc]
Chap 9 Example Shell Functions [GetYesNo etc]
Chap 10 Examples Shell Scripts
Chap 11 Debugging
Chap 12 Portability
Chap 13 Command Q&A
Appendix A - Comparison of UNIX shells
Appendix B - Syntax Summary
Index
Rating:
Summary: Recommended for Beginners and experienced programmer
Review: Lots of examples and well explained. This book is well presented and life saver for beginners scripter. Good job Bruce Blinn.
Rating:
Summary: Recommended for Beginners and experienced programmer
Review: Lots of examples and well explained. This book is well presented and life saver for beginners scripter. Good job Bruce Blinn.
Rating:
Summary: Great Shell Programming Intro
Review: The author starts off with the assumption that the reader is technically savvy but has no knowledge of shell scripting. This means that the first chapter necessarily covers basic
syntax such as creating a script file, comments, file name expansion, quotes, control structures, pipes, etc. I found this chapter extremely useful for reviewing the basic building blocks that all shell scripts tend to share. This will be a valuable chapter for someone brand new to shell scripting or Unix-style operating systems. The 4 pages covering quoting was the most lucid coverage I have yet found. Variable are covered comprehensively in Chapter 2. This chapter covers all the ways of declaring, initializing, assigning and passing variables. It also covers the Borne shell special variables, such as $?, $$, etc. I learned some new techniques for handling uninitialized variables using special Borne shell syntax, such as "". This statement causes the script to print out the "message" and then terminate if the "variable" is not initialized. The author next covers shell functions and built-in commands available in Borne shell. The 3 pages on shell functions is adequate to illustrate function syntax. The author also does an adequate job of examining function parameters, variables in functions, strategies for reusing functions and the different effects from executing a function in the current shell versus a subshell. The rest of the book shows numerous examples of functions, so the lack
of function examples here is acceptable. Next the author introduces the important built-in
commands such as : (null), . (dot), eval, exec, read, test, wait, and many others. All of the non-obvious commands have an example or two. Most of these commands are also used extensively in the remainder of the book. The point of most shell scripts is to manipulate files, so I consider the material in Chapter 4 crucial. This chapter does a fine job of explaining the file descriptors (0,1,2) and redirection of input and output. The author then discusses opening, writing, reading,
closing and truncating files. Finally, "here" documents are covered. This is a nifty feature of Borne shells which allow the creation of "inline" documents. Borne shells usually depend on the fact that they are running on a Unix-like system. In other words, most shell scripts interface with the operating system. Chapter 5 details how Bourne scripts interact with the environment they are running in. Coverage includes Environment Variables, child versus parent environments, getting user and system information, using signals, and, finally, remote commands. The coverage is not comprehensive, nor could it be. It would take volumes to comprehensively cover the UNIX environment in relation to shell scripts. With that said, the author presents a respectable subset of the most important topics. The next short chapter first reviews the UNIX command line conventions, e.g. "command [options] [parameters]". The author then discusses the getopt(s) commands for parsing command line parameters and what to do when these commands are not available. Filters are commands that get their data from the standard input, perform some transformation on the data, and then write the data to the standard output. More than one filter can be strung together to perform very complex transformations. This chapter presents an introduction to this important topic. The tools illustrated are pipes, sed and awk. This chapter, again, only presents an introduction. But the number of examples is impressive and so is the categorization. With this chapter, Chapter 8 and the man pages for sed and awk, a reader will be in a position to infuse his shell scripts with considerable power. Chapter 9 and 10 are the culmination of the previous 8 chapters. Chapter 9 provides a library of shell functions that I found highly instructive. The list of functions are: CheckHostname, Clear, DownShift, FullName, GetYesNo, IsNewer, IsNumeric, IsSystemType, Prompt, Question, StrCmp, and, finally, SystemType. The author presents an assortment of shell scripts that are written to be both instructive and useful. As with the functions in Chapter 9, I found these to be highly instructive. The list of scripts are: Cat, DirCmp, Kill, MkDir, Shar, Wc, addcolumn, dircopy, findcmd, findfile, findstr, hostaddr, and, finally, ptree. No programming language guide would be complete without the obligatory coverage of debugging. This is an area of personal interest to me, because my experience in the industry has taught me that few programmers leave the university with adequate debugging skills. The art of debugging boils down to a set of heuristics for reproducing or capturing an error, narrowing down the potential causes to a manageable set of candidates, and then progressively simplifying until the exact cause of the problem can be understood and corrected. This chapter will not teach the reader to be a competent debugger. The chapter does illustrate common pitfalls that shell scripts contain. It also discusses the basic elements in tracing through a script and even touches on shell scripting style as a tool to reduce bugs. All good, common sense information. Considering the title of the book, it would be expected that there would be a chapter on portability. This chapter presents some of the best material I have seen assembled on writing portable shell scripts. The author discusses System V versus BSD, subsets of commands, abstraction, locating commands and files, shell features, issues with a number of specific commands, and file and path names. If you are writing production scripts that may be shipped in a heterogeneous environment, this is required reading.
Rating:
Summary: Excellent resouce. Learned more in one day than two years!
Review: This book is full of tips, tricks and gottchas that take
most people years to learn the hard way. Plenty of examples
of right and wrong ways to do things. Very concise and
well written.
Rating:
Summary: A good reference
Review: This has proven to be an excellent reference. It provides lots of examples of common shell constructs and presents them in a format which should run well on bourne, korn, POSIX, and compatible interpreters. For example, I was unclear on the proper syntax for a simple "if" statement with a string comparison until I read this book. Syntax is presented up-front in the first chapter so there are no lingering doubts later on. It answered a lot of questions I still had after I finished "Learning the Korn Shell" from O'Reilley.
Rating:
Summary: Awesome Book
Review: This is a great book. It gets straight to the point, covers everything there is to know about the bourne shell and uses the least amount of words to do it. The author has done a fantasic job!
Rating:
Summary: For struggling shell programmers, you will be Bourne again
Review: This is the most complete and concise book for Bourne shell programming that I have ever seen. The pages are filled with examples and descriptions of how each line of code works. The examples also explain how to port these scripts to most flavors of UNIX. I currently have three copies of this book. One for work, one for home, and a backup
Rating:
Summary: A concise, readable reference for the Bourne shell.
Review: This is the one shell programming book that every engineer will want to have on their desktop. It is concise without being cryptic; Blinn's prose style is clear and straightforward. The concepts and syntax of the Bourne shell are explained in great detail, without reading like a man page. The examples are excellent and are explained line-by-line. If you have been frustrated in the past by 800-page behemoths filled with whitespace, pointless diagrams, and small talk, you will be pleasantly surprised. It is simply the finest book available on the subject.
| 
