Used price: $10.00
Collectible price: $15.99
Buy one from zShops for: $15.00
Used price: $31.90
Buy one from zShops for: $45.99
This book gives a lengthy and fairly comprehensive overview of software testing that emphasizes formal models for testing. In the introduction, the author gives a general overview of the testing process and the reasons and goals for testing. He carefully distinguishes between testing and debugging, and advocates these as separate activities. Testing according to the author is done to find bugs; whereas debugging is done to find the origin of the bugs and fix them. The author characterizes testing as either functional or structural. Functional testing treats the program from the user's point of view, with inputs given to the program, and then the outputs are checked for conformance to a specified reference. Structural testing examines how the program is implemented, in terms of programming style, design, etc. The notion of an oracle is defined as any program or process that specifies the expected outcome of a collection of tests. The author clearly identifies and characterizes the different types of tests that arise in development organizations, such as unit testing, regression testing, stress testing, and integration testing.
In chapter 2, the author classifies the different types of bugs that could arise in program development. Bugs are classified according to functional, structural, data, coding, system, and design and test bugs. He stresses the need to not have a religious attitude about bugs, namely that all software will have them to some degree, and therefore it is the quality measure of the software that is important in deploying the application. If a minor bug requires a major software rewrite for example, it would not be advantageous to fix this bug.
Chapter 3 takes up the notion of path testing, which, according to the author, is based on the use of the program's flow control. The tester selects a set of test paths through the program with the goal of executing every statement and branch of the program at least once. The author summarizes well the flowgraph and process block techniques used to implement path testing.
In chapter 4, the author introduces the concept of a transaction flow as a representation of a system's processing. The flowgraphs developed in chapter 3 are used here to create a transaction flowgraph for functional testing. The transaction flow representation gives a way to model the system's behavior. The author's treatment here is very detailed, and he gives several useful tips on how to conduct this kind of testing.
The next chapter covers the topic of data-flow testing, where again flowgraphs are used, but this time the focus is on exploring the things that can happen to data. Data objects should be initialized prior to program execution, and selecting paths to insure this is the goal of data testing. The author does a good job of defining and characterizing data anomalies, and the strategies employed in static and dynamic anomaly detection. This is followed by a good overview of domain testing in chapter 6. This kind of testing, more mathematical in nature than others, attempts to test whether the inputs to programs are fulfilling some prior classification or specification. The author uses concepts from vector spaces and convex geometry to describe domain testing.
In chapter 7, several attempts are discussed to quantify program complexity, such as Halstead's metrics and token counts. This chapter is somewhat more theoretical at first glance, but a lot of these ideas have found practical application in development, particularly the measures for subroutine nesting. This is followed in the next two chapters by more abstract discussion involving paths, regular expression, and syntax testing. The discussion however is useful, for it trains the reader about how to think about a program in more general, linguistic terms. Such thinking is always useful when attempting to show a particular program is acting in ways other than that which it was designed for.
Logic-based testing, via Boolean algebra, is the topic of chapter 10. The author uses Karnaugh-Veitch charts to reduce the algebraic manipulations to a useful graphical representation. Finite-state machines, so useful in all areas of software engineering, are the topic of chapter 11. The concepts are presented very effectively by the author, and the reader should take away an appreciation of how these constructions are employed in software testing.
The next chapter reads like one straight out of a book on discrete geometry, wherein graph matrices are employed to give matrix representations in software. Linked lists are used to represent the graphs in a computer, and it is shown how testing problems can be represented as a graph problem.
The last chapter discusses how to implement software testing based on the strategies discussed in the book. The three-phase test scenario is described, namely unit, integration, and system testing. An overview of commercial testing tools is also given, with CASE mentioned, but the author chooses not to review the actual packages, citing the dynamic nature of the commercial situation. However he does give a useful discussion of the different characteristics of current testing tools.
This book is written with the practitioner in mind, but can equally well be used by students in software engineering curriculums. It presents both theory and practice in a thorough and clear manner, illustrating both concepts and practical techinqes with numerous realistic examples.
All in all, in this reviewers mind, this is a very good book on software testing, in particular for the active practicioner, but could definitely be used by students of software engineering.
The politics are rough and tumble, and not without some intrique.
I would definetly recommend this to any one who has the remotest interest in this field.
List price: $15.99 (that's 30% off!)
Used price: $4.50
Collectible price: $16.00
Buy one from zShops for: $5.77
Used price: $20.00
Collectible price: $21.18
Buy one from zShops for: $20.00
As a new user to MAX I found that this book is a perfect way to see how the tools are actually used to create a scene. A couple other books I've purchased had either short tutorials that just showed a tool's application or just an explanation of the various MAX 4 functions.
The projects themselves are fairly detailed and although at a glance the book looks simplistic, it is extreme in depth for a novice. The pictures are sometimes hard to see what's going on. The text sometimes can be a little confusing but with persistance I've been able to figure out most of it. Some steps are missing in areas that to a beginner seem crucial but the fact that just about every step is explained in a simple to follow manner makes this still one of the best learning tools I've found.
I do recommend this book (along with a "reference" type book when you need a bit more explanation about a tool or function) as a way to learn step by step through hands-on for the non-experienced user.
En esta novela el autor narra los antecedentes familiares y profesionales del joven detective y después se concentra en describir los pormenores de su primer caso importante. La acción transcurre en la Rusia y Europa del último cuarto del siglo XIX.
Un cliché de las contraportadas de muchos libros puede describir la lectura de esta novela: una vez que has leido la primera página no podrás dejar de leer hasta llegar al final.
La estructura narrativa es relativamente sencilla y sigue un perfecto orden cronológico. El estilo es directo y los personajes están muy bien dibujados. En particular no es posible no sentir una gran simpatía por Erast.
En resumen, El angel Caído, es una buena novela detectivesca, que mantiene el interés del lector de principio a fin y que promete varias horas de una lectura fluida y particularmente amena.
Buy one from zShops for: $170.59
A decent read, and better than most crappy Conan-novels not written by Robert E. Howard, though still lacking that certain pulp feeling.