Customer Reviews

UNIX Shell Programming, Revised Edition

5 star:		(32)
4 star:		(12)
3 star:		(3)
2 star:		(1)
1 star:		(1)

 

 

"UNIX Shell Programming, 3rd Ed" (USP3E) is probably the book to buy if you're a beginning UNIX user with dreams of writing shell scripts. The book does a good job of explaining many of the key concepts needed to get real work done on UNIX systems. While readers with advanced backgrounds will prefer a book like "Mastering UNIX Shell Scripting" by Randal Michael, USP3E will please most UNIX scripting newbies.

USP3E begins with a review of the basics -- working with files and directories, redirecting input/output, pipes, and the shell itself. Chapter four's discussion of regular expressions is generally useful, although "saving matched characters" on p. 64 was confusing. This made the "command substitution" material on p. 129 unclear. Chapter six was devoted to the use of different sorts of quotes, which seems excessive until one realizes the significant differences between using single and double quotation marks in scripts. Attention to detail like this, along with generous inclusion of sample scripts, helped this book earn a strong rating.

While the book includes examples of using sed, awk is not mentioned. Sed could have received more coverage as well. While the authors direct interested readers to other books, perhaps a future edition might include chapters devoted to sed and awk? While the publisher's site doesn't mention a source for errata, it is available by contacting the authors.

Overall, I liked this book. It is up-to-date and compares favorably to the other books I consider reading to learn more about UNIX shell scripting. Armed with the knowledge gained from USP3E, readers should be equipped to automate some routine tasks. They will also be able to progress to more advanced shell scripting resources.

I am a perl and C programmer, and I am very familiar with the shells outlined in this book. So the material was not particularly "new" for me. I can see how it would be difficult to understand for a user who was new to shell programming.

If the intended audience is the intermediate unix user who knows something of programming, this book gets a full 5 star, my seal-of-approval rating. Terrific.

One thing it is lacking is a brief mention of perl or of awk. In many cases, it is simpler to write:

date | awk '{ print $2 }'

instead of:

date | cut -d' ' -f2

or, at least from the standpoint of understandability and readability. but the book doesnt claim to be a manual for awk, and oreilly has an excellent book on the subject.

I continually recommend this book to people, and where ever I go, I find this book on the bookshelves of successful people.

I bought this book when it was originally published back in 1990. I started with little programming experience, and no shell programming experience. It brought me up to speed quickly. I no longer write many shell scripts; however, I still use it as a desk reference when I do. For any UNIX system administrator, this book (or one just like it) is essential.

BTW, I have been looking for a better book all these years and haven't found one. It's not that I think this book is perfect, rather there just aren't many good books on this subject.

Although published in 1990, this book could still function well as an introduction to UNIX and (Bourne) shell programming, provided one is aware of some changes to the shell in most implementations of UNIX since that date. Also, the Perl language has come on strong in recent years, and depending on your tastes (and time), that language can be used with great efficiency to do the tasks that are traditionally done in the shell.

After a quick review of the basics of UNIX, the authors give a purely descriptive explanation of the UNIX shell in chapter 3. Emphasizing that it is an interpretive language, the most commonly used shell commands are discussed in chapter 4, starting with a discussion of regular expressions. The cut, paste, sed, tr, grep, uniq, and sort commands are treated in detail.

In chapter 5, one begins the actual task of creating shell programs using shell variables. There is no data typing in the shell, so values can be assigned to variables without noting their type as integer, float, etc. The authors only briefly discuss the mechanism in shell programming. The method by which the shell interprets quotation characters is covered in the next chapter. The single, double, backslash, and back quote characters are discussed in detail. Noting that arithmetic operations are done on values stored in variables in the shell, the authors show to proceed with these operations using the expr program.

The mechanisms for passing arguments to shell programs is treated in chapter 7, the authors showing how to write shell programs that take arguments typed on the command line. The role of positional variables for delaying assignment after normal command line processing is discussed. The $#, and $* variables are discussed briefly, with $# getting set to the number of arguments typed on the command line and $* used for programs taking a variable number of arguments. The shift command is explained well as a method to allow one to use more than nine arguments to a program.

The ability of shell programs to execute decision blocks is treated in chapter 8, via the if statement. The role of the test and exit commands are in if blocks are discussed in good detail. In addition, the case command, familiar to C programmers is introduced as a technique to allow a single value to be compared against other values. The && and || constructs are used to show the reader how to execute commands that are contingent on the success or failure of the preceding command.

Program loops, via the for, while, and until commands are discussed in chapter 9, followed in the next chapter by a discussion of how to read data from the terminal or from a file using the read command. The ability to perform I/O redirection is discussed also.

Local and export variables are discussed in the next chapter on the user environment, and the authors give a good summary of how these work in shell programming. More discussion on parameter passing is done in chapter 12, with the different methods of parameter substitution given detailed treatment. The authors show how to use the $0 variable to check whether two or more programs have been executed, and how to use the set command to set shell options and to reassign positional parameters. This is followed in the next chapter by a discussion of the eval command, which makes the shell scan the command line twice before executing it, and the wait command, which will allow serialization in program execution. The trap and type commands are discussed also.

The Korn shell is discussed in chapter 15, with emphasis on the features added to Korn shell that cannot be found in the Bourne shell. The vi and emacs capability of this shell is briefly discussed in this chapter. The differences between Korn shell functions and Bourne shell functions are discussed in detail by the authors. Most importantly, the ability of the Korn shell to do integer arithmetic without using the expr command is discussed via the let command, which is built-in to the Korn shell. Also, the capability of the Korn shell to support data typing is discussed, along with its pattern matching capabilities. Pattern matching is done most efficiently now using Perl however.

I have had this book around for many years and I still
Find myself (and my colleagues) referring to this book.
Over the years I have bought many shell books and certainly
Have found other books that cover certain aspects at greater
Depth. For example, the book definitely lacks
a good coverage of awk and I have found O'reilly's sed & awk
to be a very useful awk book. I also like `The new Korn Shell'
by Morris I. Bolsky and David G. Korn for it's indepth coverage
of the advanced features of Korn shell. But this is still
the best Introductory shell programming book that I have come across.

This book is good only for beginners. If you have scripting skills in another OS and want to learn UNIX shell programming to do real life scripting, this book will only give you cursory knowledge. It does not cover any useful scripting techniques. Overall, I would say you will need another book alongwith this to do what you want to do.

I have been using this book since 1992, and I have not seen anything better.

First 100 pages should be mandatory for every person new to UNIX ( users, developers, systems administrators and system engineers ).

There are errors, however I never got upset with that.

Let me start by saying that most of the Unix tools like sed, awk, regular expressions, even vi, deserve their own specialized books and there are excellent books on these subjects.

This is the only book you need as a general foundation to overall Unix shell environment. It is more convenient to start with this book and then dive deeper with the help of books like "Learning VI", "Mastering Regular Expressions". Yes awk is not covered, but it is not a big loss since awk was kind of not the part of native tools and it most definitely needed its own book to master as well as Perl.

Then after you are done, most definitely for a daily use obtain "Unix Power Tools"



This book is excellent for two audiences.

For beginning programmers new to Unix. It should be their only general purpose Unix book, followed by specialized books. Also it serves to veterans that were away for a while from Unix and need just to brush-up very quickly without going to minute details of every tool.
I for one, used this book as part of both audiences. I got acquainted with Unix with help of this book as well as refreshed my knowledge a year ago after long hiatus.

Back when dinosaurs roamed the earth and NCR made Unix computers I first started to program for a living. Back then when someone said `script' they meant a shell script, generally for a Bourne shell.

Now that we have languages such as Perl and Python, much of shell scripting has been forgotten. The need still arises for the times and places where running Perl would be just that little bit too much overhead; cron jobs, process start and stop scripts, even machine start and stop scripts. For these we could best go back to the old ways. Combining the power of the common Unix tools, pipes and scripts in a fairly obscure and slightly arcane syntax is not easy to pick up, though the language's simplicity does, in some ways, make it easier than more complex ones such as Perl. Unix Shell Programming, Third Edition does a good job at introducing shell programming and I found it an excellent book when I needed a refresher.

I don't want to sell this volume short: you won't just learn about shell programming. The first ninety or so pages provide an excellent guide to getting the best out of the shell, and the last chapter is devoted to the features specific to an interactive shell such as command-line editing and using the history.

The authors have chosen to use the POSIX standard Bourne shell (`bash', available on many *nix systems, is a superset of the POSIX standard). That seems the right decision, given that it is so universally available and usually the default shell.

The book is well structured, starting out with a brief look at *nix operating systems before introducing the shell followed by some basic tools; cut, paste, sed, tr, grep, sort and uniq. One minor quibble, the book explains how to redirect STDOUT to a file and STDERR to a file, but not how to redirect both to the same file. That aside, these few chapters provide a good introduction to the shell.

The text goes on to systematically explore shell programming starting with variables and arithmetic. The chapters are kept short, in a good order and have a number of exercises at the end of each. The structure of the book and the order each new concept is introduced is well thought out; at each stage small examples are given that only use material already introduced and are complete in performing a task. In early chapters they are fairly trivial but by the end there is a fairly complete rolodex program written in shell script that would be a good model for anything you wished to do.

There is also a good summary of the shell syntax and common commands in Appendix A and good `Further Information' in Appendix B. Kudos must go to the authors for a list of books for further reading that is not ashamed of mentioning other publishers, indeed they say "One of the best sources of books on Unix-related topics is O'Reilly and Associates" and list volumes from them before mentioning their own publishers.

There are some small typographic errors in the text but I did not find any in the script examples I tried. I found it to be well written and readable throughout, perhaps an advantage of a third edition in a slow moving technology.

I would recommend everyone read this book once or twice, it provides a comprehensive, well written tutorial on one of the most basic (and often overlooked) tools at your disposal. Even Windows users could install Cygwin and gain the benefit of a good POSIX compliant shell and this book. It also has the advantage that once purchased it will be useful for many, many years to come - the language has not changed noticeably in twenty five years and should not change in another twenty five.

A clear and concise intro text for beginners. Wording is kept short clear and to-the-point. Examples are very clear. Exercises are not tricky and test your plain knowledge of what you covered. Chapters are short. It is clearly a beginner oriented text and is not intended for advanced users.