Customer Reviews

Classic Shell Scripting

5 star:		(7)
4 star:		(6)
3 star:		(0)
2 star:		(0)
1 star:		(0)

 

 

Classic Shell Scripting
Hidden Commands that Unlock the Power of Unix
By Arnold Robbins, Nelson H.F. Beebe
First Edition May 2005
ISBN: 0-596-00595-4
558 pages, $34.95
[...]

I found this to be quite a useful book for learning more about Unix/Linux shell scripting. I would consider this one to be an intermediate level text, and complete beginners might be better served by a more simplified book. There are quite a bit of in-depth details included, and many very nice examples and code snippets. Like all O'Reilly books, it is well organized and formatted, and clearly written.

The book opens with a brief history of Unix and how important the shell (and scripting) is to it. There are some comparisons with other programming languages, and why it is sometimes preferable to use a script versus a compiled program. The very basics of how scripts are written and used are also mentioned here, and beginners may want to refer to an additional book for more of the basic instructions.

The next few chapters cover mostly text processing with scripts, including searching, sorting, printing, extracting, and counting methods. Good examples are used, including the use of regular expressions and pipes to increase the power of your scripts. Following this, there are several chapters on more advanced scripting, including how to use variables, loops, functions, standard I/O, redirection, wildcards, using "awk", and working with external files. Extensive example code is provided throughout.

The remaining chapters of the book get into more advanced subjects such as database manipulation, process control, and increasing the security of scripts. Portability and shells other than bash are also discussed.

Perhaps the most interesting part of the book (for me) were the Appendices and other sections at the end. Appendix A is entitled "Writing Manual Pages", and is extremely informative on how to produce and format a valid man page. This is a much more complicated process than I had previously known (can you say "groff"?), and is quite interesting. For anyone who has ever complained about a poor man page, this will give you all the tools you need to write an improved version! :) Appendix B has some excellent in-depth discussion about Unix files and filesystems, including attributes and permissions. Appendix C is a summary of important Unix commands for shell scripting, categorized by function, which is a good quick reference list. Following this, there is an excellent Bibliography that recommends related books for further reading. Finally, there is good Glossary and an Index.

Overall, I found the book to be excellent in it's content and quality. I would recommend that a beginner also find a companion book to more gently introduce the fundamentals of shells and scripting, but this volume is excellent for the intermediate to advanced user. If you want to fully use the power of the Unix/Linux shell, this is a "must-have" book! Well done to the authors and O'Reilly Publishing.

Great book. The emphasis is nicely split between actually using the shell itself and the whole supporting cast of unix tools (sed, awk, cut, join, sort etc.) The idea of carefully crafting solutions using the unix toolbox mindset is key. I also like the fact he doesn't try to teach to multiple shells, but first tries to emphasize portability by sticking mainly to a POSIX standard, and only later adds info about non standard shell topics. If I could only have one book on shell scripting, this would be it. The best description is 'Practical'.

This might be a great second book on shell scripting. Can serve as a valuable add on to "Learning Korn shell" from O'Reilly -- also a very strong book on shell scripting.

The authors provide a lot of interesting and useful information that is difficult to find in other books. They devoted Ch 5 to piping and in 5.4 "Word List" they discuss famous Doug McIlroy alternative solution to Donald Knuth program of creating the list of the n most-frequent words, with counts of their frequency of occurrence, sorted by descending count from an arbitrary text file.

The authors discuss many Unix tools that are used with shell (Unix toolbox). They provide a very good (but too brief) discussion of grep and find. Discussion of xargs (which is usually a sign on a good book on scripting) includes /dev/null trick, but unfortunately they do not mention an option -0n with which this trick makes the most sense.

One of the best chapters of the book is Ch. 13 devoted to process control. Also good is Chapter 11 that provides a solution to pretty complex and practically important for many system administrators task of merging passwd files in Unix. It provides a perfect insight into solving real sysadmins problems using AWK and shell.
Shortcomings are few. in "5.2. Structured Data for the Web" the authors should probably use AWK instead of SED. Also XML processing generally requires using a lexical analyzer, not regular expressions. Therefore a tag list example would be better converted to something simpler, for example generating C-tags for vi.

This is the book that I have been waiting for years for. It's classic O'Reilly, but it's better than that. Even the O'Reilly books have fallen short of being truly useful for shell scripting. I think this was primarily because the authors have been thinking more about language fundamentals then about teaching useful things. This book is targeted towards teaching shell scripting through practical application. This is the shell scripting book to get.

The purpose of this handy little book is to help someone who is working with Unix through the labyrinth of tools available and learn how and when to use them. It is important to note what is mentioned in the preface - "Throughout this book, we use the term Unix to mean not only commercial variants of the original Unix system, such as Solaris, Mac OS X, and HP-UX, but also the freely available workalike systems, such as GNU/Linux and the various BSD systems: BSD/OS, NetBSD, FreeBSD, and OpenBSD." I quote the book because the word "Unix" is about as descriptive as the word "car". The intended audience is anyone who is computer literate, already knows how to program, and is regularly faced with diverse problems in the workplace that must be solved with Unix tools. This book should give you a taste of which tool to turn to and when.

This book can be divided basically into two halves. The first half is a tutorial on writing Unix scripts. The book starts with a brief history of the Unix language and the philosophy behind Unix tools. Slowly, each chapter builds up your skill at script writing. You are shown how to differentiate between shells, how to work with text extensively, how to use loops, pipelines, variables, and decision statements, and how to work with files. There are detailed example scripts at every step along the way. By the end of chapter seven, you should know enough about basic shell scripting to be dangerous.

Starting in chapter 8, you are showed more application-related information. First, Chapter 8 shows and discusses some ready-made scripts for some tasks for which there is no out-of-the-box Unix solution. Some of the handy solutions shown are for path searching and automating software builds. Chapter 9 is a crash course on awk, and is aptly named. It is just enough to be dangerous. You learn how to solve common text processing problems with awk, but you'll need more resources to be really knowledgable. Chapter 10 explains the usage of common commands for listing files, modifying their timestamps, creating temporary files, finding files in a directory hierarchy, applying commands to a list of files, determining the amount of filesystem space used, and comparing files. Next there are two applied chapters showing you how to merge several databases and how to perform spellchecking by using scripting. Chapter 13 changes the subject a bit and talks about the concept of processes in Unix and how you can use their statistics to accomplish a number of monitoring and control tasks. Chapter 14 talks about problems you may run into if you try to take advantage of shell-language extensions, while Chapter 15 addresses the issue of writing secure scripts to the extent it is possible to do so. Writing man pages, and the basics of the Unix filesystem are the subjects of the last two chapters of the book.

I would say it is a good modern introduction to the subject of shell scripting and Unix tools and how to use them. It doesn't dive deeply into any particular topic, but it will get you started by broadly introducing you to the problems most Unix script writers and system admins face regularly and how to get started solving those problems. I highly recommend it for that purpose.

"Classic Shell Scripting" by Arnold Robbins and Nelson H. F. Beebe is a decent text on portable shell scripting, which also contains a fair amount of awk. Though written in tutorial form, it explicitly assumes that the reader knows how to use the shell interactively and, as I show below, in some cases implicitly assumes that the reader already knows the basics of shell scripting.

The Good: Robbins and Beebe have created a pedagogically sound book which contains tables, fascinating digressions, sidebars (with major options on tools, along with caveats), an annotated bibliography, as well as a glossary. The book can be read straight through, since each chapter builds on the preceding ones, but the aforementioned resources are especially handy when using this book as a reference. Were it not for the tables and sidebars it would be difficult to look up things like how to set the field separator in different tools (-t in sort, -d in cut, -F in awk) or how to ensure case-insensitivity (-i in grep, -f in sort). The topics the authors cover throughout the book are interesting, but the real meat is in chapters 3, 6, 7, 9, 10, which discuss regular expressions, sed, awk (Robbins is the maintainer of gawk and also the co-author/author of books on awk), control flow, command evaluation, and file manipulation. Most of the other chapters are applications of the topics introduced up to that point, and serve to drive home the lessons already learned (though there are pleasant exceptions to this pattern, e.g. the section on crontab in ch. 13, or the material on the Unix filesystem in Appendix B). The writing is generally relaxed and at times borderline silly, e.g. "exit 42 #Return the answer to the ultimate question" or "root) nasty stuff here #Danger Will Robinson, danger!". Importantly, the entire book is focused on scripting that is compatible with the POSIX standard(s) (e.g., the authors prefer printf to echo) -- it is similar in that sense to Peter Seebach's book on portable shell scripting from Apress. Apart from the pointers on the behavior of different shells scattered throughout the volume, the authors have also devoted ch. 14 to portability gotchas and shell-language extensions.

The Bad: despite the tutorial nature of this text, it does have a few pedagogical flaws. These include the use of concepts before they are introduced (e.g. here-documents are used in ch. 4 but are mentioned by name only in ch. 5; the ${varname:-word} operator is used in ch. 5 but is not defined until ch. 6; the authors use >&2 three times in ch. 6 before pointing out that they will explain it in ch. 7). Such minor slip-ups extend to the use of concepts that are just not explained anywhere in the book (e.g. in ch. 3 the d command in sed, or in ch. 5 the -c option in grep). In yet other cases, the authors simply do not practice what they preach (e.g. in ch. 7 they recommend $() for command substitution, but then use `` in all but one of the examples in chapter 8, titled "Production Scripts"). On a different note, using this volume as a reference is not as easy as it should be. Tracking down an explanation months after you've finished reading the book can be frustrating, as I will illustrate with a specific example: the index entry for globbing says "see pathname expansion"; going to the index entry for pathname expansion we are pointed only to p. 496 (the glossary entry for that term), but not to any sections in any of the chapters. In the glossary entry on p. 496 we are told that globbing a.k.a. pathname expansion is also called wildcarding. Heading back to the index, no entry for wildcarding is to be found; there's an entry for wildcard expansion, instead, which looks relevant. Unfortunately, that entry not only points to irrelevant sections, but also ends with the inimitable "see also pathname expansion". All the while, subsection 7.5.2 is titled "Wildcarding", but you wouldn't get there simply by using the index. Sadly, the table of contents is similarly unhelpful in this context, since it includes sections, but not subsections.

This book could be shorter, but it's still worth reading. I especially enjoyed the sections on regular expressions and on awk. As already explained, readers who know nothing about shell scripting may find this a difficult read, so they might want to first go over "Learning the bash shell" by Newham & Rosenblatt or a similar volume. Finally, access to an ebook version can make up for the deficiencies of the index when using Robbins' & Beebe's text as a reference. All in all, 4.5 stars.

Alex Gezerlis

This book provides a nice overview of the Bourne/sh shell's commands. I wish there were more examples with complete scripts. Korn shell users might want to consider "Korn Shell: Programs for Your Survival at Work" by Larry L. Smith. Bash users might want to consider "Bash Shell: Essential Programs for Your Survival at Work" by Larry L. Smith. Some of the examples in Randal K. Michael's "Mastering UNIX Shell Scripting" are also helpful.

I've scrolled through lots of books, there is so much information out there, but this book has a tendency to keep it simple and to the point. It has good illustrative examples that not only are useful but also serve as a good practice guide.

This book tackles the concept of writing UNIX scripts not by telling you how to
write 'canned scripts,' but rather explains the various commands you will use to
create shell scripts. The book does this by extensively explaining various commands (like echo, tr, ls, grep, sort, etc), providing manpage-like descriptions of the command and its options and even code snippets. I found this to be quite helpful in understanding them.

My favorite chapters were the ones devoted to Text Processing and Working with Files. I've worked with UNIX a lot over the past fifteen years or so and have lost count of the times I had to move or delete files or directories. I knew there had to be a way to automate some of this, but I never got around to learning about them until now.

This is a great book to have not just to learn more about shell scripting, but also to understand the numerous UNIX commands that go into creating scripts.

Who does "classic shell scripting" nowadays?
Maybe some IT geek, hackers, linux distribution developers... and embedded engineers!
If you develop embedded system based on linux, you will have to do with sh scripts & friends.
You can do a lot of things with a good script, better than writing your-own-cross-compiled-c-code.
This book can help you in going deep and use the power you have immediately available even on the smallest linux busybox installation.
I liked it, I enjoyed reading it, and it helped (and helps) me in my work.
I found the awk chapter a bit less good, but this is not a book on awk.