Customer Reviews

Exploring Expect: A Tcl-based Toolkit for Automating Interactive Programs (Nutshell Handbooks)

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

 

 

Expect is completely unlike any other tool I have ever used. Think of any language you've used and how long it would take to: write a program that can update 1000 user passwords on 20 different machines; make two chess programs play each other; connect two users to the same shell program and type at the same time; allow you to rewrite the command arguments to any command line tool?

Expect really does make all these things trivial. It takes a lot of patience to master this tool though; Tcl is a very unforgiving and terse language. I've done things in Expect that I never thought were possible: I scripted Minicom (a modem term program that uses ncurses) to answer a phone after 7 seconds, and either: receive a zmodem file or send a login prompt. Then hang up the modem and wait again. Try that in a shell or systems language!

It's unfortunate that Expect is such a radically different beast and takes so long to understand; every person running regression tests or doing systems administration will benefit from this book. While it may not be great for just "looking up" things, search Usenet for all of the author's posts (comp.lang.tcl) and his answer is almost always, "This is on page XXX of the book." Because the book really does cover everything Expect does!

This book is terrific. Libes writes very smoothly. Everything is answered and just at the right time - whenever I was wondering about a point, I would turn the page and find my question to be the next topic covered!

I really thought Expect was a simple-minded thing. Then I had a question about how to do something. I was bemoaning my problem one day when a coworker thrust this book into my hand and said "Read it!" Wow - not only did it have my exact scenario as an example but now I see Expect can do so many more cool things. I originally thought Expect was just good for telnet. But Libes shows examples applying it to all sorts of other programs. The breadth of the examples alone is incredible. It's obvious that Libes has really been around and poured all his wisdom and experience into this book.

I also liked the special command and variable index (the book calls it "Appendix") which is a 2nd index that takes you directly to where each command and option and variable is definitively described. There is also a third index of just the examples - some of them are useful in their own right (apart from demonstrating some concept). Between these and the regular index, it is always easy to find things later.

I wish all tech books were written this well.

When I discovered Perl I though it's a quick and dirty way to automate admin tasks. I was wrong. The really quick and dirty way is Expect. Expect works like Helpdesk hotline. You call them and they ask you what you see and tell you what you should type. Sometimes you just have no alternatives especially if you're short on time. But the language is pretty tricky (e.g. if you want to look for '$' in regexp, you should use '\\\$' pattern, etc) and I couldn't learn it using just examples included in the distribution package. Then I spent some time searching for the good tutorial and this book was the best I found. Expect is surprisingly poorly documented and I didn't find any other books about it. There are some articles in the Internet, but usually they don't give you the whole picture. This book includes many examples, easy stuff in the beginning to get you started and very advanced in the end. That's everything you need to learn expect and it's written pretty friendly. In some places it's very informal but not too much.

The only book about Expect, so one cannot compare it to others. But it serves it's purpose. Expect is a Tcl extension with about forty extra commands and variables to handle interactive processes from a script. This capability is unique to that Language. With ExpectK one can use Tk as well. I read the book in three nights, because it was such a help to my sysadmin tasks on UNIX. But despite all my propaganda, only one other person picked it up for writing a chat robot. The book is a must for every UNIX admin, if he is free to use the languages he likes, which is, unfortunately, not the case in many banks.

Expect is a life saver in our unix environment and Don Libes has done a great service to the sysadmins of the world by developing this tool. If I could rate expect, it would get five stars and Libes would get a metal for making my job easier. However, for the book, three stars for poor organization (and everything else previously mentioned by a frustrated reviewer from Boston). I get so frustrated paging back and forth in the book, holding the index with one finger, trying to find the little code snippits I need to do the job. The book starts off well enough and there are wonderful techniques which I have been able to adopt, but as the book proceeds, and the examples get more complex, the explanations wane. How 'bout it, you exepect experts, is anyone out there willing to develop the "Expect Cookbook"?

Exploring Expect is a decent book on the topic. I suspect that most Expect users are also Linux users, and there is a "figure it out on your own" attitude in that community which is reflected in this book. The reader is given just enough information to figure it out on his own. That is, the information is not in 'for Dummies' format, but it isn't as clear as most would like, either. Also, I think the reader will more easily understand the text if he or she has experience in Unix/Linux and C programming.

I've come to "expect" computer books to deliver information in succint form, followed by useful examples. Instead, this book reads like a novel. The only way to understand anything is to read from start to finish. And without a companion TCL reference it's hopeless. Many keywords are used and discussed in passing, but never defined.

The index randomly references word matches within paragraphs instead of topical sections. (Someone must have used a blind "find" function since the index was obviously an afterthought.)

A language with such a narrow purpose and small command set shouldn't require nearly 600 conversational pages. I admit I didn't give this book much of a chance, but as my only available reference to this subject, I am very frustrated. I loved the O'Reilly Perl book. How could they have strayed so badly with this one?

I used Expect to interface security code, which could not be altered in any way, to GUI's and did it with scripts of less than 30 lines of Expect script for each comand. Expect allowed me to idiot-proof my code by generating diagnostic GUI's for each type of erroneous input. The book should be read from cover to cover because each succeeding topic depends on learning the one before it. Timeouts are a very important topic and the use of "exp_continue" and "set timeout nn" to control them. I wish the author had told me earlier about "exp_internal 1" to activate Expect diagnostics. Without this command, you are flying blind while debugging your Expect script.

This book, along with Ousterhout and Sun's references on the www, comprise the triolgy that is jump-starting my learning tcl. I find the index compete and easy to use and I frequently jump all around the book gleaning little nuggets of information. I am also concurrently reading it cover-to-cover because I like Libes's style -- the way he throws in his programming phylosophy with his examples so you can see why he's doing something a certain way.

I like how the author addresses issues of portability without obsessing on it.

I really like the Exercises at the end of each chapter. I only wish the author would apply a difficulty rating to each exercise because sometimes I can't tell if an exercise is intrinsically very difficult (some are definitely so) or if I need to review parts of the chapter to see why I can't just instantly 'get it.' In any event, the exercises are stimulating and would require a long time and careful thought to do them all. I would buy a book that had the answers, with commentary, to all the exercises.

This was a great book to get started with expect. I was writing scripts in about an hour. I primarily wanted to learn expect to work with Cisco Routers and this was a great primer into making that happen!