Customer Reviews

Portable Shell Programming: An Extensive Collection of Bourne Shell Examples

5 star:		(21)
4 star:		(3)
3 star:		(0)
2 star:		(0)
1 star:		(2)

 

 

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 "${variable:?message}". 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.

Although I've been shell programming for years, I still learned a lot of new material from this book. Unlike Bill Rosenblatt's book, "Learning the Korn Shell", this book is extremely well thought out and presents subjects in a logical order. I would even recommend this book to people new to shell programming. In addition, unlike most of the other books I've read, ALL of the examples actually work! Mr. Blinn has even taken the time to make sure the examples will work on most every platform (Solaris, HP-UX, ULTRIX, ...).

As the book states, we learn shell programming best by looking at examples of shell scripts. This book is a gold mine of examples which are practical and applicable to a System Administrator's every day job. They really help to reinforce some of the more advanced and/or cryptic shell programming features. Mr. Blinn also does an outstanding job of explaining each shell script in detail. He does not leave the reader guessing or confused.

To be fair, I have to include the fact that the diskette which came with my book was blank. However, by following the instructions in the book I was able to download them from Prentice Hall's FTP site in less than 5 minutes.

A great book for learning shell scripting. It starts out with general syntax but then the rest of the book in filled with micro examples of things you need to write scripts, like input, output, prompting, changing case, manipulating strings, parsing and extracting data, finding file sizes, checking free space, setting screen echo on/off, read with a timeout, text substitution, doing math, here files, etc. There are also sections on portability, debugging, and common problems. I am very happy with this book and use it often when I am scripting.

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.

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

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.

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.

I have been looking for a book like this for quite some time now, and FINALLY I have found it! If you are tired of jumbling syntax when changing from one shell to another (or from perl/tcl/etc scripting back to shell scripting) then this is the book for you!

This book will also serve as a fine introduction to Bourne shell scripting for novices who learn best by example.

All too often, authors present man-page-like syntax guides that contain all possible flags and switches (which can conflict with each other). Bruce Blinn uses real pieces of *working* code to illustrate the uses of the various components of a shell script. HIGHLY RECOMMENDED!

As opposed to other books with "practical" in the title, this one lives up to its name. I found Chapters 4 (Using Files), 5 (The Environment), and 7 (Using Filters) very helpful. The book is full of many examples of practical things, such as how to delete all blank lines in a file. This makes is valuable for the beginner, and the later chapters contain information for the more advanced shell programmer.

I got this book at a time when the guy who wrote all our shell scripts quit without notice. This book was a lifesaver, as I had to write short (and not so short) shell scripts to automate certain tasks & understand the work he did.

I would like to see more discussion in Chapter 7 (Using Filters) about combining the use of sed and the Unix/Linux command tr. I find that I have to use these together sometimes as one does things the other can't handle. This is the only suggestion I have to improve an already useful book.

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