Software Testing Books

I took and passed the test in October 2006. I found that many of the questions on the 2005 Exam covered areas not in this book. As other reviewers have posted, I also used Michael Jang's RHCE Prep guide to flesh out the weak areas. The exam itself leans toward RedHat so it is not surprising the exam prep does too, and why Yang's prep guide was so helpful. So my advice is get this book but also get Jang's book also.

Read the book entirely, reviewed, and learned all the information. There was an abundance of questions on the Linux+ exam that were not mentioned in this book. All the questions that were covered in this book I got right in the exam and still didn't pass. One question that came up in the exam was " How do you finish off a while statement" and nowhere in this book gives an example of a while statement. I happen to know now that the answer is "done" thanks to another book. That is only one example of many. Other than that, I do believe this book is well written and has resourceful information.

I found this book had alot of useful material and little filler. The book provides useful commands and common examples for using those commands without filling it with a bunch of man pages like some books. It also gives some key tips that will be helpful to any system administrator. I thought there should have been more information on system services like apache or mailsend, but maybe those won't be really covered much on the exam.

The questions at the end of the chapter, as mentioned by other users, aren't very useful, so you'll likely need to test yourself with other resources.

Don't be fooled by some reviewers who try to dispute the book with petty inconsistencies. They often are more interested in sounding like they have been diehard linux users all their life than actually giving any reliable feedback.

Pros: good coverage of cli commands, concise information without filler, useful tips that help you become a system administrator.

Cons: bad end of chapter questions, somewhat disorganized in the way the content is presented.

In this book you can found a good start to the Linux+ Cert.
It dont have electronic material. It is a con.
Another good book and a great complement is Roderick Smith's Linux+ Study Guide from Sybex...
Best wishes in your cert!!
JRB

This is a good book to prepare the Linux+ certification.
There are chapters on hardware and software in which you can find also basic informations those could be useful also for technicians to recall knowledge. If you are a Linux expert you could find too easy, but it gives you all you need to understand the topics of the exam.
I'll use it also as reference in the future.

Very helpful book. Haven't tested yet but I will pass. Good analogies. Not such boring writing. Will be reading another source to be sure I am ready though. Excellent source of info. Will be good for future reference as well.

The book provides an excellent and, I feel, comprehensive, review of the meat needed to pass the Networking Essentials exam. It may not teach you enough about troubleshooting and logical thinking about networks, I didn't concentrate on that part of the book. But if you have a basic understanding of networking, this book will assist you in memorizing all of those specifications (cables, protocols, etc) you need to know inside and out for the exam. With 4 exams now down, I got my highest score yet on this exam.

Used this book, along with Testout demo as study guides. Very concise and to the point, although lacking in a few areas. This was my 5th test taken. Scored 933 yesterday. Make sure you take the other Core tests first.

I like all the Exam Cram books. But they all have the same weakness. They are crams and not comprehensive texts.

Still, I thought it was a good place to start. Most of the material is valid and a good foundation for the other exams.

I would supplement it with other more comprehensive books like the Microsoft Network Press book--those are the opposite and give you too much information that will bog you down and put you to sleep. Use both and pass.

The exam crams do what they claim. Give it as much as possible in the quickest way. I recommend this book for anyone studying for this exam.

Used this book as a last resource and it was worth it, very neat presentation of RAIDs and very clean illustrations. Lacking on a few items like troubleshooting tools how to read them. Read this a the last thing it will be worth it Passed yesterday with 966.

For .NET developers new to test-driven-development who want a recipe for the process, an invaluable book. This is not a concept book, but rather a concrete example that gets a little loose towards the end. Those who have also adopted Model-View-Controller for their ASP.NET applications will be able to logically extend the first half of the book to test their web interfaces, something that is admittedly difficult using the "stock" ASP.NET design philosophy.

I would supplement this book with Pragmatic Unit Testing with nUnit and C#, which gives you a much higher-level view of how to utilize TDD on a daily basis.

Test-Driven Development in Microsoft.NET rises head and shoulders above the other books on the subject. While I know that is a very strong statement to make, the authors have made the focus of the book a very practical one. Don't get me wrong, there are several other great books on this subject, but they all seem to fall down when it comes to real-world situations.

The book is split into two parts; Part I is an overview of Test-Driven Development, and Part II covers using TDD to develop an example application.

Chapter 1 frames the entire discussion with an overview of Test-Driven Development concepts, including some straightforward guidelines for design. I thought it was laid out in very logical fashion.

Chapter 2 throws you right into the process it's a classic stack example, found in many other TDD books. What I liked most about it though, was that the chapter began with discussing HOW you start figuring out WHAT tests to write as you develop an application.

Chapter 3 covers another critical concept of TDD Refactoring. (What's Refactoring? You askread chapter 3 ;) ). Again, the authors walk you through a short yet concise primer using the Sieve of Eratosthenes implemented in C#. They introduce the algorithm and then discuss it in light of code refactoring techniques as implemented originally in Martin Fowler's Refactoring: Improving the Design of Existing Code.

Chapter 4 is the introduction of the example application that will be the focus of the remainder of the book. It lays out the scenario, project features and constraints of the fictitious project.

Chapter 5 covers an area that I've found generates a ton of interest when developers start thinking about TDD, namely data access. I really appreciated the practical approach that the authors took when writing the implementation chapters for the example application. I found the tests surrounding entities and relationships and the resulting explanations to be very good.

Chapter 6 covers how you create tests when implementing Web Services. In the process, the service interface pattern is discussed along with refactoring Web Services. The authors attempt to lead you through a "thought framework" for creating tests through each of the implementation chapters.

Chapters 7, 8, and 9 make a shift from programmer testing to customer testing and cover differing aspects of customer or acceptance testing. This group of chapters starts with an overview of acceptance testing and techniques. The middle chapter deals with driving development up through the implemented layers from a user or customer perspective. Chapter 9 rounds out the discussion by focusing on handling faults and how acceptance testing allows you to tighten things up.

Chapter 10 leads us back to the programmer testing side by dealing with transactions. Following this, Chapter 11 introduces the reader to Service-level refactoring, leading you through the thought process behind different techniques. The story winds down in Chapter 12 with applying the process of TDD to implementing a web client.

All in all, while I'd have like to have seen a both a simpler example and always more "real world" tips and tricks, I can tell you from my own experience that finding that balance is extremely difficult. I believe the authors have made a significant attempt at striking the "real world" / simplicity balance and that the resulting outcome is an excellent resource for learning TDD. When that is combined with the level of effort the authors are putting in to maintaining the code and forums at their GotDotNet workspace, this makes Test-Driven Development in Microsoft .NET an excellent choice for your library.

I attended a workshop on test driven development presented by James Newkirk. I was so intrigued with the concept that I had to go out and get his book to find out more. As a result our project now uses NUnit, TestDriven.net for test driven development and find that this has really boosted confidence in the developers and their code. The concept of test-driven development is a very useful agile method of writing code to the requirements based on tests (Red/Green/Refactor). This has certainly changed my perspective towards development and want to thank James Newkirk for purveying this concept.

Many people think that Test-Driven Development (TDD) is all about testing software. In fact, test-driven development's main goal is not testing software, but aiding the programmer and customer during the development process with unambiguous requirements. The requirements are in the form of tests that the software must pass along the development process.

This procedure helps to insure that problems are found early and corrected while they are still small.

This book first discusses TDD from a conceptual point of view then gives a TDD example using a realistic application.

This is a great book for experienced developers. It covers a wide range of realistic uses in .NET and has plenty of detailed examples. It gets you into the mindset of Test-Driven Development (TDD) in good increments. The NUnit discussed is a free download and is very easy to start using with your own software quickly, so you can come up to speed right away and begin using it on your projects. One of the better TDD books that I have read, possibly the best. It will certainly remain on my bookshelf for some time.

Whether you are a novoice or have been practicing TDD, this book is worth reading. It is really well organized, has great examples and explains how to use available TDD tools.
Great job, David!

Context: I've read a fair amount about TDD (including being a technical reviewer for Kent Beck's "By Example" book), but went a long time without getting a chance to use TDD. David Astels' book gave me a chance to get a little down and dirty with the technique and some of its associated frameworks.

Maybe too dirty? As others have said, the source code in Part III of the book doesn't do what the book describes; you need to go to Mr. Astels' web site and get updated source code.

I found the coverage of Java frameworks (in part II) to be very helpful; it expanded my understanding of what TDD techniques can be used.

(Disclaimer: I worked with the author on one large project).
Dave Astels' book is a comprehensive work covering TDD from the ground up to advanced topics. While most of the book examples use Java and JUnit, it does cover unit testing frameworks in several other languages as well. I've read two books on the topic (the other one is Kent Beck's "TDD By Example") and I liked Dave's book better. The basics of TDD can be explained in 10 minutes however when it is applied on practice it gets complicated in at least 3 areas: 1) testing UI 2) testing with database - data setup, isolation, etc. and 3) mocks. Kent's book is more about a philosophy of TDD but it only goes through a very simple "toy" example. Dave's book really helped me to understand mocks and it does cover UI testing in great length. Mocks are an advanced topic, so it does require a good knowledge of Java and OOP. The rest of the book seems to be on intermediate technical level.

The only thing this book is missing, I think, is a discussion about data setup and database-related testing, dbUnit, etc., other than an advice to avoid it altogether (p. 83). While you can indeed use mocks to avoid it, on the large real projects some kind of integration testing (including testing with the database) will be necessary. I hope the second edition will come out at some point!

Overall, it's a great book for both newcomers and developers with unit testing experience. BTW, it won SD West 2004 Jolt Award.

This book is about Test-Driven Development (TDD). Its purpose is to help you write better code (by having more tests) and give you a head start with existing tools to achieve this.

The book falls short of these goals: The explanations about writing tests are short on advice and are sometimes misleading. The presentation of the tools is long, with little useful facts.

The book is organized into four parts: Background on TDD, refactoring and programming by intention; A look at JUnit and related tools used to write and run tests; A lengthy example of TDD; An overview of other tools in the xUnit family. The book is targeted at a Java audience but programmers using other languages should have little difficulties understanding the code.

I have a major problem with the background section. The author repeatedly claims that TDD provides exhaustive test coverage and ensures that you can refactor your code with confidence. Any error will be caught by the tests. This is foolish. First, tests rarely reach 100% code coverage. Even the sample that the author provides in the book ends up with less than 90% coverage. This leaves many gaps where tests will fail to detect errors. Even if tests cover 100% branches in the code tests are not exhaustive. Depending on the data used, the same branch may exhibit different behavior. (Not to speak about race conditions and other sources of hard to find bugs.) I fully agree with the author that writing unit tests will improve the quality of the code and help find bugs. But claiming that this is a silver bullet is not wise. I would recommend reading books about tests (e.g., Myers' The Art of Software Testing and McConnell's Code Complete chapter on unit testing) in addition to this book. The section on refactoring is a summary of Martin Fowler's Refactoring book which I recommend.

The second part presents JUnit. JUnit is a framework used to write and run tests. It is a good presentation. However I would have liked to get pieces of advices on what tests to write in addition to how to write them. The author briefly mentions boundary testing but does not have much to say about the tests themselves. Again a test book is invaluable for this. The author recommends using a test coverage tool as well as Jester to measure the tests coverage. This is a great idea.

The third section is an (overly) extended example: the author walks us through writing TDD code. This could have been a great part, giving meaning to the `practical' adjective in the book title. Unfortunately it is a long rambling, showing lots of code but short on insights. The actual `meat' of this part could be summarized in less than five pages.

The last section presents variations on the JUnit tool. Many languages (C++, C#, VB, Python, etc) are discussed. This part would have been better put on a website rather than printed in the book. Given the changes in some of these frameworks the information is obsolete.

The books ends with several appendices dealing with extreme programming and agile modeling.

Unit tests are a great tool to improve code quality. Whether or not you actively practice TDD, a good book on it can provide insights into improving your code. This book contains some interesting bits of wisdom. However much of it is buried by the rest of the material.

Dave's book does one thing that most other books in this field do not do: it avoids the web application. Hallelujah!

This book provides a good foundation for understanding TDD: the programming cycle, refactoring, tools, mock objects... it is possible to begin applying TDD for yourself after reading the first 1/3 or so of this book.

Writing effectively about programming sessions is not easy. Only a few authors can do it well, and Dave does an admirable job in this. My only beef with the case study (which makes up the bulk of the book) is that, after a while, it becomes somewhat repetitive. This isn't Dave's fault: it's the nature of programming. Sometimes we just need to add another button or another text field. We don't necessarily learn anything new doing it, but if we want a finished product, we have to do it. I understand Dave's desire to present a complete (if small) project, and so applaud his willingness to risk some duplication in the name of finishing what he started.

The experience of learning from this book is similar to learning from real project experience: not every page contains something new and exciting, but if you follow along and ask questions (of yourself), then you will have learned a great deal by the end.

I read about a dozen of books about testing, and I put this one into a reference for my workers. This is short and very robust. My highest rank.

This book is very interesting to learn or to progress (I have 10 years of experience in software developpement) in Art of Testing. The only tedious point is that the author are not really integrate the new principales of Test Driven Development in its book. So, I advise to read a book on this subject before or after.

Benoit, a French Programmer ;-)

The Art of Software Testing provides the novice with the essentials for developing and implementing a comprehensive testing approach. It's also a valuable resource for those with experience. I dive into this book constantly.

The premise is simple enough: How can you write effective test cases that adequately exercise your system requirements? Myers suggests that good software testing depends on the answer. Testing what the program is supposed to do is only part of the battle. However, in my experience, this is usually where we plant our flag. This can be difficult enough, depending on the quality of the criteria. Bad or vague requirements necessarily lead to insufficient and flawed testing.

As a result negative testing, boundary testing, testing for unexpected conditions, and so forth will often go by the wayside.

In addition, testing is often presented as a gateway to production, and can be cursory as a result. The creativity and time that adequate test cases demand are simply not within project scope. This is often exacerbated by intent to pass systems without finding errors.

Myers addresses these issues as he explores test planning and creation. Hence this book really belongs on the shelves, not only of software testers, but project management as well. The methodology of requirements-based testing is not new. However the profession is growing and more sectors are discovering the need for testing their systems. Art of Software Testing is still relevant and should be promulgated.

This book is expensive, however it is well worth its price. A top 10 book for IT professionnals.

It's hard to give the appropriate number of stars to this edition. On the one hand, this is one of the classics of the field, and deservedly so. In it's first edition, this may have been the first great book on testing, and there is something about the "first great book" on any topic that makes it a lasting value decades later: DeMarco on Structured Analysis, Brooks on the wicked complexity of software project management, Booch on object-oriented design, K&R on C. And so I think it goes with The Art of Software Testing. It's a short book, and full of good ideas that will stay with you.

But.

This revised edition is simply a terrible value. At the full list price, you'd be paying something like fifty cents a page...and, let me tell you, a book had better revolutionize my life for that kind of money. I'm a dedicated capitalist sell-out software developer, but this kind of pricing arouses even _my_ hacker sensibilities. Also, the value of the revision is questionable: there may be a chapter on Extreme Programming, but it seems to me that the best material in this book is still the classic text that survives from the 1st ed. So, my recommendation is that you simply _buy_ the first edition, new or used, at a fraction of the price. Then, you get nearly all of the benefit, plus the cachet of having the "classic" on your shelf. You can put it right next to "The C Programming Language" and "The Mythical Man-Month." Then, your visitors will know you're a serious software developer...and, you know what? They'll probably be right.

I also like and recommend Kaner, Falk and Nguyen, "Testing Computer Software," for a more in-depth and up-to-date treatment of testing issues.

Buyer beware. This book does not reflect the many changes to JUnit implemented in version 4. I found it to be a very good book when it came out four years ago however.

pragmatic Unit testing in java save a lot of time to debug java code.

JUnit Testing can really save you a lot of time debugging. This book provides a various way to work with JUnit.

This is another fine book from the "Pragmatic Programmer" series. If you are doing Java development, but haven't gotten into unit testing yet, this is a great place to start. The book is a quick read - I made it through in two days. The book gives background on why unit testing is important and then tells you how to go about doing it with JUnit. The book has practical advice for the kinds of things to include in unit tests while it finishes with design considerations for make code easier to test. To get the most out of the book, you need to download the code from the author's web site and work through the exercises. It is great how they have taken a critical topic and made it extremely accessible. I highly recommend it.

This book is very good for a beginner to unit testing. I like the simple explanation of the different types of unit testing that must be done. This really helps a beginner to make sure that the tests are comprehensive.

Also it clarifies the intention behind use of mock objects. I would use the concepts in this book as a checklist to make sure the tests are written to cover all types of problems.

I gave 4 star only because it contains toy examples and does not go into too much detail on this very important topic. JUnit Recipes contains more realistic examples.

Bas has already done a good job outlining the content. I won't repeat that here. Instead I will say that TDD is hard. It took me several years of trying before it all came to together for. In the past few months I've recommended this book to more than a few developers in the past six months.

In at least two of those cases it has been the turning point in their understanding of Test Driven Development. Net result - I'm can spending my time coaching/mentoring in other areas.

I had been trying out Test Driven Development from past couple of years and found it very interesting. Its a time consuming process in the begining but once we jump into it then everything will go smoothly.

This book provided me a good cross verification point and corrected me in lot of places. I feel its a good investment for all Java Development Team.

As an experienced developer in an XP shop, I am always on the prowl for good books on TDD. Alas, this is not one of them.

The author uses a lot of exclamation points! And little puns! And a conversational tone that is both annoying and condescending.

In addition, he quotes so many other books that I felt as though I should be reading *those* books instead of his.

Much better material can be found for free at the various XP and Agile resources on the Web.

This book is an great resource for Java developers wanting to get started on TDD. It covers the majority of tools and techniques available, along with useful tips and best practices.
The first part is already worth the book's price. The author presents TDD and its benefits, shows how it works with a lot of coding, and ends it with an excellent chapter on concepts and unit tests design patterns. By the end of it you'll feel eager to, at least, give the practice a shot.
The book proceeds showing how to test technologies commonly known as "hard" to unit test, like web components, database access code, threads, and swing. Although the author doesn't go into too much detail in any of them, he presents good solutions to make their testing easier.
The last part is a very good introduction to Acceptance TDD and how to write tests with Fit. It is not as thorough as the TDD introduction, but will give you a very good understanding of what ATDD is, how it should be done and how it can (and should) be complemented with unit testing.
Essential reading for Java developers looking for ways to improve the quality of their code.

Great book. I've read Kent Beck's book, but his book is a bit dated these days. I found Test Driven to be a nice, timely refresh of the TDD and refactoring topic. I've done some mentoring and teaching on TDD and refactoring lately and I've been evangelizing this book to my students/participants. Well worth the money.

This book was helpful in passing the Enterprise exam. You will DEFINITELY need some hands-on experience before attempting the exam with this alone, of course you should always have experience before trying any cert. What's the value in being a *paper* cert? Anyway, if you have moderate experience with NT this book can be very helpful in passing the exams. I will definitely buy from the Exam Cram Series again.

If you've already passed the NT server exam and you read this book, you won't have any problems with NT Enterprise. Make sure you know all the stuff in the practice tests at the end of the book and you're set! By far the best exam prep book I've read.

This was the fourth exam cram book that I have purchased and I havn't been disappointed yet. This book has a lot of good information that will help you prepare for the exam. My only complaint is that the chapter on Network Monitor should go into a bit more detail. I got hit with some hard question about examining packets and network monitor usage. It would have helped to have some more detail on these subjects.

I definitly recommend this book to anyone who is pursuing taking the enterprise test.

I just got back from my certification exam, so I feel that I can provide a true review for this book. First I'd like to say that I've been working with NT for a couple of years now and I'm not lacking hands on experience. Since I felt that I know NT pretty well already I've been relaying mostly on the exam cram books for my studies. This is the 5th exam I've taken so far (I took NT Workstation, Server, TCP/IP and IIS 4.0 already). I've passed them all on first attempt without fail and used the exam cram books plus different prep tests for almost all of them (I used the Lisa Donald `Test Success' for IIS). However, for this specific subject I am rather disappointed. I feel that this book did not prepare me for the exam like the others did. I passed at a disappointing 635 (passing score 560-adaptive). The other material I used (MeasureUp.com prep tests) was not that helpful either. Since I'm not aware of any Microsoft changes to this subject since this book was published, I would recommend you look elsewhere if you need a quick study guide. If you know NT already, you'll probably pass the exam with this book. However, if you want to be safe, look for other sources. Perhaps the Lisa Donald `Test Success' did a better job on this subject too. Please note that I will recommend the other Exam Cram books that I've used before (i.e. Workstation, Server and TCP/IP)

Good Luck. Oshri Feldman

This book allowed me to pass the exam the first time through. I have two years practical experience and this book pulled together the rest of the information I needed. Great book and well written.

Even advance users like myself can pick up a trick from this book. But it is targetted toward newbies who maybe interested in becoming an intermediate user. The layout is excellent as well as it's content. The author knows how to keep you attached to the topic.

THIS BOOK TALKS TO MUCH ON HARDWARE THEN SOFTWARE. THIS ISNT THE A+. GO FOR ANOTHER BOOK, STAY AWAY FROM THIS. IM RETURNING THIS TO AMAZON.

Linux+ In Depth is a well written book that starts off exploring basics so fundemental that a reader should already be familiar with them if they are planning to take this test. Beyond that, the writing style flows well and keeps you reading. Ultimately the nearly 700 page book progresses into much more advanced topics. I recommend this study guide to anyone planning to sit the Linux+ exam.

I got a 780/900 (passsing is 655). I knew this book about as well as you possibly can and that was my score. Honestly, the book was great. Very readable, and understandable. Lots of information,etc. The problem is the exam. The questions are all over the place and many don't make much sense. As with most certs its a poor measurment of technical capabilities that is designed to give inqualified management the warm and fuzzies about hiring a new employee.

last week, I finished reading the whole book. I thought I was ready for the exam. I bought the exam Cram book just to practice, I knew only about 40% of the practice exam, the rest were never covered in this book. However, I think the book is very easy to understand. Very well written. YOU DO NEED ANOTHER BOOK TO GO ALONG WITH THIS ONE FOR THE EXAM (for example, Exam Cram Linux+).

Sybex Linux+, is also a perfect book. some of the practice exam in Sybex Linux+ were the exact questions on the real test.

We bought these books to teach us come finer aspects of Visual Test, and they do just that -- to an extent. Unfortunately, after the first several chapters, it quickly becomes useless, barely covering some very important aspects of the product (file I/O, pointers), and spending entirely too much time explaining how to test Wordpad. I would rather have a good reference for this product than this.

It seemed a little half-baked. It was good in some areas, but for the most part lost usefulness quickly. I can't in good conscience give this any more than a mediocre review.

I can't begin to say enough good things about this book. 700 pages of material that covers the product from A-Z, and then some!

The book starts off with a history of the tool, explaining how it evolved from an internal Microsoft utility to the version now owned by Rational Software. Next it goes on to touch on the development cycle and where automation should (or in some cases shouldn't) fit into that process. This section alone was worth the price of the book because it added weight to what I've been saying about how to approach automation effectively and RESPONSIBLY.

It continues on to describe where everything is installed on the machine and why. Very helpful information especially for test engineers who are always ripping their systems apart. Break something in VT when mucking with your system and this will help you get VT running again quickly.

The next section goes on to cover the entire UI, language and utilities, and gets the reader started with a simple coding example.

Part III of the book is where the rubber meets the road: Building a Test Suite. Such topics as coding guidelines, determining what approach to take, starting out with simple test cases, and creating common (and sharable) utilities are clearly illustrated.

The final section is for when you're comfortable with your automation and want to get into some advanced topics. Arnold goes into working with pointers, working with binary files, callbacks, linking into APIs, the works. He also discusses how to write scripts for running tests remotely on multiple machines over a network. Lastly, he talks about how to automate HTML testing using Internet Explorer.

The appendices -- especially Appendix A -- are very helpful. Appendix A lists the entire Visual Test language (something that every "bible" should have). He even lists features and routines that aren't documented in Rational's own documentation! Tom also lists other sources of information, including this excellent discussion group he created that has over 1000 subscribers who help each other get the most out of the product.

The CD-ROM not only has all of the code examples from the book (as you'd expect), it also has video interviews with QA experts (including Dr. Cem Kaner, author of "Testing Computer Software"). The CD even has Adobe Acrobat PDF versions of the book's chapters. Don't want to carry the book with you? It's all on the CD. Pretty slick. I've not seen many (any?) other books do that.

Even if there were other VT books out there (and there aren't), this would be the one to buy. This guy has gone through the process and figured it out, and fortunately wrote this book to tell the tale.

This was the book that introduced me to VT6. I bought the tool myself and decided to start automation. The book started off giving any newbie what is needed to get started. I spent a few days reading the book. After about chapter 7, I started writing my own inefficient scripts. Although I didn't care for examples that kept pointing to Notepad (other automation tools' manuals have the same concept) I did get a sense of what was being demonstrated. The shortfall of this book is it's not in-depth enough. I suspect the fact that advanced topics were not covered sufficiently is because the author teaches classes on VT6. When I was ready for the advanced topics, I was completely lost because the book would give a simple example and then give a difficult one. Nothing in between. I had to consult an "expert" at my next job and I learned a whole lot more. They too bought the book hoping they would learn a few tricks. They were sorely disappointed and called the book useless while I found it useful, only as a beginner. I've not used the book since then and probably never will except to see if I can get something out of the advanced topics section now that I am more familiar with the tool. When the author says the Suite Manager is completely written in Visual Test language, I scratched my head because the book doesn't give a clue as to how it was possible. Advanced topics need another book but as long as the author is teaching classes on that, I don't think he'll give his secrets away in a book. Buy it if you're a beginner. Leave it if you're well versed in VT6. It's not going to give you much. Rather, borrow it instead. Too bad there aren't other books on this fine tool.

When I started a new job in the QA department of a software company accompanying my studies, I hardly knew anything about automated software testing and test scripts like Visual Test.

I was given the "Visual Test 6 Bible" in order to learn Visual Test. Within a few days reading the book, I successfully was able to write my first test scripts doing exactly that, what was expected.

The book was pretty interesting to read, easy to understand, at least for me being an intermediate C++ programmer, and quickly leading to results.

The only negative aspect of this book is the name, 'cos a book called "bible" should give a bit more in depth information, but since I currently am satisfied with the knowledge I gained by reading this book, I don't really miss it, just thought a different name could have matched better.

Mr. Arnold's book offers both a helping hand for slow starters and a great jumping-off point for those that want to hit the ground running.

We weren't certain where to begin so we bought this book and it helped us understand that there are times when automation makes sense and there are definitely times when it should be put on the back burner.

When automation should be brought in to play, though, this book has extensive source code examples, a great language reference, and is encouraging every step of the way. He also points out key aspects of the product that aren't clearly documented by the software manufacturers (or not documented at all!).

Thanks, Tom, for your great writing style and for making our jobs easier!