Beginning Portable Shell Scripting: From Novice to Professional (Expert's Voice in Open Source) Paperback – November 21, 2008

I highly recommend this book to anyone who kinda knows Linux, or maybe is a Mac user wanting to automate some stuff through the shell. I find this book rather similar to Mastering Regular Expressions. I say this because like with the "Owl Book", after reading the first three chapters, I had enough in my toolbox to start writing real scripts. This is great for 2 reasons: it gets you up and running quickly, and also provides a HUGE amount of depth past just the fundamentals. I will be using this book as a reference for years to come.

I want to emphasize that I don't recommend this book as a first book on command line/shell scripting. It assumes you know the basics like ls,cd,cat,cp,mv, and maybe at least a little bit of grep. If you don't thoroughly know all those commands and use them often, you should wait to get this book until you're a little more comfortable with the command line. But for $0.01 new ($4 with shipping), I would say just go ahead and get it. This book has got the be the best value I've ever gotten for a penny!

Peter Seebach's "Beginning Portable Shell Scripting: From Novice to Professional" is a relatively recent text on shell programming. Even though its focus is mainly on the least-common denominator of a huge variety of shells (including POSIX-compatible, older, and embedded ones), the author also mentions a number of extensions, in the hope that knowing about them will help the reader in one-off scripts, will facilitate understanding of non-portable scripts, and will also make it easier to avoid them.

The Good: Seebach's writing style is enjoyable. At times he's funny, e.g. "The name octothorpe is my favorite because people are completely consistent in not having any idea what I'm talking about"; most of the time he's mildly amusing, e.g. "If you can't write to standard error, you can't display a message on standard error saying that you can't write to standard error"; and throughout the book he just gives off a pleasant vibe. It's important to note that the relaxed tone is not really distracting, i.e. it does not interfere with the flow of the text. Seebach has included a multitude of best practices and common idioms from all aspects of shell programming. Some are pretty simple, e.g. the X"$answer" = X"42" test idiom; others follow from his focus on portability, e.g. don't use test's -a or -o operators -- stick to the shell's logical operators instead; and yet others have to do with security concerns, e.g. if you really need a temporary file, you have to be in control not just of the file, but of the directory it is created in. Throughout the text, Seebach is interested in shell features that will work on the vast majority of available (or not-yet-available) machines, e.g. to determine if ls is built-in the author does not mention the POSIX type command but recommends using PATH="" ls; echo $? instead. Seebach also covers material others exclude, e.g. instead of using the expr utility only for arithmetics he employs its colon operator to use regular expressions in the shell. What is perhaps the book's strongest point is the large number of trivia points, some of which don't seem really useful, e.g. multiple here documents in a single command line, or seem to have outlived their usefulness, e.g. the ${1+"$@"} idiom. Others are minor points that are still worth knowing about, e.g. the fact that a line continuation character is ignored inside a comment in shell but not in make. Yet others seem to be minor details which have serious consequences, e.g. a shell function body does not have to be a code block: it can be a subshell instead (though Seebach doesn't use the term "code block"). On a different note, even though the author doesn't refer to many other books (see below), he does provide a number of pointers to the external world, e.g. to parts of libtool or autoconf, as well as to a very interesting Pike/Kernighan paper on cat -v. Finally, the text includes a number of tables, the most interesting ones containing information that is not readily found elsewhere, especially Table 2-7, which shows the possible interplay between () and | when dealing with regular expressions, and Table 5-1, which is a compendium of information on shells calling shells via eval, command substitution, function calls, etc.

The Bad: first off, the book's title is orthogonal to its content. If someone does not know shell scripting (portable or otherwise) this book will not be able to teach them in any sane manner, as it is chock-full of cases where concepts are used way before they are introduced. (The book's title may not be the author's fault, but that is beside the point.) At the same time, this volume doesn't really discuss "advanced" shell scripting material (e.g. bc, cron, command) either -- though half a page is devoted to explaining the difference between a slash and a backslash. Still on the subject of what Seebach leaves out, it's worth noting that this volume does not include a table containing options/switches/expressions for the test command (like the -s, -f, -d, -n, -z, -x that the author sprinkles throughout the text). This is even more problematic when one takes into account that such necessary information is included in both introductory volumes (e.g. O'Reilly's "Classic Shell Scripting") and intermediate texts (e.g. Apress's own "Expert Shell Scripting"). The relationship of Seebach's text to other volumes is interesting: he writes that "whole books have been written" on one subject, that "there are other books that go into much more detail" on another topic, and that "there are wonderful books and tutorials available" on yet another subject, but fails to mention any of these (in the entire volume, the author explicitly mentions only two books other than his own). This is also related to Seebach's often idiosyncratic terminology: when discussing regular expressions he calls *+? "repetition operators", but it's important to note that the POSIX and bash documentations simply call them special characters and Friedl's classic calls them metacharacters. One's terminology should also be portable. Speaking of which, it's very disappointing to see the author's first printf example contain both a typo and a real portability blunder. If one tries to run name="John" printf "Hello, %s!\n" "$NAME" on any shell, $NAME would be an empty string (this should say $name). The more specific problem, though, is that history expansion in an interactive bash shell is similar to csh, so the exclamation mark doesn't do what the author thinks it does -- this problem can be eliminated through imaginative use of quoting or by disabling the feature with set +H. In ch. 7, Seebach adds insult to injury by claiming both that ! is expanded within single quotes (it isn't) and that interactive history expansion is off by default "in modern versions" (it never was and still isn't: bash versions are available via ftp). There are many other problems with this book. Most significantly, there are numerous errors in the code and in the alleged output: e.g. in ch. 4 I counted 5 typos in the 3 pages on the ${a:-b} forms, while in ch. 5 in only one line of code we find both bzip2 and bizp2 (!) as well as unbalanced quotes. The code examples seem to have never been tested. Another problem, hinted at earlier, is related with sed and awk: these are used throughout the book but are not introduced until ch. 11. That chapter is followed only by the Appendices which, incidentally, contain 80 pages of publicly available reference material. One gets the feeling that Seebach should (and probably could) have written a different book, more along the lines of the "Effective C++" and "Effective Java" texts, which provide insights and best practices but do not pretend to be reference or introductory works.

In a nutshell, this book does not really fill a gap in the bibliography: Robbins and Beebe's "Classic Shell Scripting" covers similar portability-oriented material, in a text that is both a better reference and more pedagogical, and which also teaches you some awk in the process. On the other hand, the book under review is quite short, its writing is generally pleasant, and it does contain some nuggets of wisdom here and there, so I'm giving it 2.5 stars.

Alex Gezerlis

I've been using the UNIX shell for about fifteen years now and actually felt pretty comfortable with it. I can't believe how much I've picked up from this book.
I'm a software programmer and have to deliver binary programs and shell scripts to customers. These customers often do not have the more modern UNIX shells. Additionally, they're rarely authorized to install non-OEM software on their carrier grade, mission critical systems. Sometimes they're not even allowed to install software that came with the boxed unit on a free, extra CD-ROM.

This often leaves me with nothing but good old Bourne SHELL to work with.

Everything is covered, the history of "Why they did this", to advice on writing scripts that will be run on embedded systems. The book contains scores of great shell scripting idioms.

When I do my UNIX systems programming I use my Richard Stevens book.
When I do my UNIX shell scripting I use this book by Peter Seebach.

This is not a beginners guide to UNIX shell scripting. It's a beginners guide on how to write or modify your scripts so they'll run everywhere. But even the experienced shell script writer will pick up a great deal more from this book than they expected.

Nice work Peter.

If like me, you find yourself having to work with different shells at work and home, and need to write baseline utilities, this book can help you accomplish things quickly.
Even if you do need to write more involved programs, this book can still help you.

Overall, a refreshing look at shell scripting in general. Many thanks to the author for his time and effort in compiling this book.