5 comments about Unit Test Frameworks.

1. I have put off writing a review of this book because I had very mixed feelings. On the plus side, it is a very clear concise guide to unit testing - a great introduction.
   
   On the negative side, I figured that any decent programmer already knows what's covered here. Even those who don't write unit tests (bad programmer, bad) knows what they are and how to do it.
   
   Then I was stuck on how to unit test in a particular case and the author email me - look on page 37. And there it was.
   
   So, if you are learning to program - GET THIS BOOK. No one will hire you unless you know this. If you're an experienced programmer, it can still teach you a thing or two.
   
   - dave thielen
   
   ps - the author is a friend of mine and that did cause me to round up my 4.5 rating.



2. This is a very solid, no-nonsense introduction to unit test framework.
   
   For a 200 page book, this one is packed with carefully chosen information, detailed enough for new comers to start unit testing, useful enough for a frequently-visited reference, and at the same time concise enough for anyone to get an overview of the unit test landscape.



3. I have been using JUnit for unit testing on Java for quite a while and I have also been exposed to other testing frameworks, but had never looked under the hood is such detail as Paul does in this book.
   
   He starts with a good overview of what a unit test framework and then takes us to a very nice tutorial on building your own unit test framework from scratch. This exercise is very well documented and you learn the basic principles behind a unit test framework while building a simple application and the unit tests required to test it.
   
   After laying out the foundation, he goes on to explain in more detail how to write unit tests, how to use assertions, how to deal and test exceptions and expected errors, how to test protected behavior, how to organize your project for testing and using more advanced techniques like mock objects and performance testing.
   
   He also includes a chapter that deals with testing GUIs (Graphical User Interfaces) which is a challenging task, but he offers good ideas for doing test driven development for a GUI to the application that we have been building during the previous chapters.
   
   After all the basic concepts have been covered, the next chapters are dedicated to the most important (or more popular) unit test frameworks which are JUnit for Java, CppUnit for C++, NUnit for C# on .NET, PyUnit for Python and XMLUnit for XML documents. It is interesting to note that throughout the book the author uses the same application for the example code, so that we can compare the actual implementation of the tests using the different frameworks.
   
   In the appendices, there is a C++ version of the simple Java framework that was built on chapter 2 and there are also summaries of the class reference documentation for JUnit and CppUnit.
   
   Overall I think it is a very solid book with good examples and very concise content. Even though it doesn't cover all the unit test frameworks that exist today, I think it covers the most important ones, but the real gem is on the in-depth analysis of what makes a unit test framework.
   
   If you are already familiar with one or more unit test frameworks, this book will give you a deeper understanding of them, and if you are still programming without writing unit tests... shame on you ;-)... buy this book and learn how simple it is to have a very good unit testing framework, no matter what language you use.



4. I had used JUnit for several years before picking up this book and I like to think that I know the tool pretty well. So why did I decide to read this book? I read this book because I thought that might help me venture a bit outside my familiar JUnit turf and into doing test-first programming with languages other than Java. The short version? A very nice introduction to all the included xUnit ports. The long version? Read on.
   
   The first four chapters are general introduction to the topic of unit testing (and to some degree, test-driven development). I was prepared to do a quick scan through them all but ended up reading chapters 3 (xUnit architecture) and 4 (writing unit tests) almost word to word-the topic was mostly familiar but the authors solid writing kind of kept me going.
   
   The first two chapters didn't pique my interest that much, perhaps because I had already seen people develop a unit test framework from scratch as an introduction to the domain.
   
   The real meat of the book that I was looking forward to was in chapters 7 through 9, the introductions to CppUnit, NUnit, PyUnit-which were mostly new to me although I had done very little fooling around with them before. I wasn't disappointed. The author managed to put together a pretty good set of tutorials for these frameworks. Obviously the same information is available online but I still prefer reading a treekiller rather than a printout of a web page.
   
   The not so bright spots in the book, in my opinion, were the chapters on unit testing a Swing GUI and on XMLUnit. Not that they were in anyway badly written. I just felt like they didn't belong. I would've personally swapped in a couple of additional xUnit ports instead (Ruby and PHP, for example).
   
   This is definitely not a book you'll carry with you from project to project. There's approximately 100 pages of substance split among half a dozen topics so none of them gets covered in detail. The rest, almost 100 pages of the book is what I'd classify as "nice to have"-I don't mind having that material in the book but I also wouldn't have minded if they'd left them out.
   
   To summarize, if you'd like to get an idea of how the unit testing frameworks on different platforms/languages differ and what they have in common, this is as good an introduction to them as any and well written in all dimensions. However, you might be disappointed if you're looking for a more long-lasting companion.



5. [reviewed by XPSD member Paul Hamill]
   
   Unit testing and test-driven development (TDD) is a skill that has been desperately lacking on many of the projects I have been involved with over the last few years. I have tried reading books by Kent Beck and others on this subject, but I have always had trouble getting to the next level of applying the skills to "real" problems. This book does not take the approach of claiming to teach you how to be a great test-driven developer, instead it is a survey of the unit test tools available for many environments today and along the way explains the fundamentals of unit testing and TDD.
   
   If you have read other books on TDD, you may find much of this book a review, however there are many explanations of how some of these tools would be used in actual projects which I found valuable. The discussion of mock objects is a good one which explained some details about how to use mock objects in practice that I didn't understand in reading other sources on the subject. In addition, several tools I was unaware of were discussed that I am interested in looking into for making TDD easier to do. For example, XMLUnit and NUnitForms are 2 tools that would seem to make testing a data-driven GUI application much more manageable.
   
   I would recommend this book for anyone who has an interest in unit testing or test driven development and wants to know what tools are available to do this. Also, this book would be invaluable if you intend to write your own xUnit framework for a language.

5 comments about Software Project Secrets: Why Software Projects Fail (Expert's Voice).

1. George Stepanek's Software Project Secrets: Why Software Projects Fail surveys the reasons why software projects fail: most commonly conflicts between software developers and project manager goals. It's the first to analyze how project management's goals conflict with software development - and to provide a solution to the time and budget goals of managers and the accuracy of software developers.



2. I work for a software company as a Senior Technical Writer, so when I reviewed this book, I expected it to hit close to home. It did.
   
   In the second of two software development firms I have worked with, I realized that the issues which George Stepanek brings out in his book were the same challenges for each company. All parties involved had their own agendas but none of them followed the same methodologies for getting things done, or they found their methodologies did not exact work with Software Development projects.
   
   This is especially true when it comes between the Software Developers and the Project Managers. The Project Managers tend to see only their schedules and not the challenges of the Developers, such as time, code requirements and adequate staffing. I think sometimes the Developers live, eat and sleep at the office to try to get the software to GA (General Availability).
   
   At the end of a development project, many times you look back and try to figure out what went wrong, or what steps to avoid for next time. I think it is wonderful that Stepanek details the key factors which cause a project to fail. Many Project Managers look at the specifics of a software development project only to find they can't quite figure out the difference between this type of project and the others. Fortunately, for the reader the author identifies twelve facts that make software development so different from other projects. With these facts, clearly in hand, Project Managers and Developers can come closer together to make the project a success. Unique to this book as well, Stepanek also identifies ten wrong assumptions (in his analysis of the "Project Management Body of Knowledge") that are made by managers and how to avoid them.
   
   Stepanek also takes a look at three modern project management methods. This is a topic that many books on Software Development and Project Management fail to address. He details what parts of each methodology works to solve some of the issues of software development projects. Almost more importantly, Stepanek identifies the areas in which these tried-and-true methodologies fail to solve the unique problems of software development projects.
   
   Going one step further, the author discusses seven different techniques that can be used by Project Managers to ensure that the projects come in on time and on budget. This should be music to Project Managers' ears!
   
   One thing I do like is the illustration of a point or an example. Stepanek includes a case study at the end of the book which shows what challenges can appear and how to cope with them successfully.
   
   This book should be required reading and a great supplement for the Project Managers, Product Managers, Software Developers and even customer who have been trained to use the methodologies commonly used in the industry, but still have project that fail or are difficult to manage to completion.



3. If you've been or had been working on a software project, you will know what George is talking about. Small of big, a software project never fail to challenge you with every-growing requirements (so the complexity), unexpected obstacles, and never-enough-time. The book well analyses the nature of software project and provides a good insight of the real challenges/issues we face when working on a software project, so to help us deal with them better. Very useful to read.



4. The book compares software project management from a number of "agile development" perspectives to the PMI model for project management. The book illustrates assumption made in the PMI methodology, and provides a counter point or rebuttal to those assumptions. Thus the book suggests the PMI model is not entirely applicable for software project management. While this book challenges some of the PMI methods, it provides alternative approaches to achieving project success. I liked the book, and appreciated the examples, even when I did not fully agree with some of the assertions.



5. When I first read this book about two years ago, I wasn't that impressed. I thought author George Stepanek spent too much time explaining things that seemed obvious, and was indecisive in the recommendations he made. Having a few more years experience under my belt, I have a better sense for author was getting at and more of an appreciation for the book.
   
   The first section of the book runs down 12 challenges of software development that make it unique from a project management perspective. This section is mostly valuable for novices, but objective enough to be worth reading for veterans as well. The author makes a particulary good point in that software development is research and that you're inevitably doing something new each time. However I find the real value in this section is that it allows the reader to objectively judge the processes introduced later in the book.
   
   The approaches that Stepanek advocates are all clearly in the Agile realm. The three methodologies discussed are Crystal, Rational Unified Process, and Extreme Programming. This is probably the only book I've ever read on software development process that doesn't advocate one methodology over another. Stepanek recognizes that different approaches apply to different situations, and this is one of the book's biggest strengths. If you're unfamiliar with any of these three approaches, this is a good book to start with.
   
   Stepanek brings things together with a pair of case studies, which he uses to contrast the traditional waterfall approach to the more modern Agile methodologies. The Agile case study is of more interest; Stepanek blends techniques from different methodologies and shows how they can be used in conjunction to solve different problems. The case study is somewhat limited in scope, but it provides concrete examples of using the techniques described earlier in the book. By blending techniques from different methodologies, the author avoids a "one size fits all" recommendation, which I've found other books prone to.
   
   The one thing to be aware of when reading this book is that its content is better suited to developing internal applications rather than external production applications. The thinking is more geared toward an environment where budget and schedule are more important than things like user experience and performance. If you're contributing to an internal software project in any role, I'd recommend giving this book a read.

5 comments about Excel 2002 Power Programming with VBA.

1. This book can be included in the handy tool category, a "must have" for non-programmers who want to give their Excel applications a professional look as well as get the most out of Excel without wasting much time and effort. Word of caution, a bit of familiarity with visual basic as a language and the controls etc. will be very helpful in using this book. Codes in the CD are very helpful. It is written by a practicing professional from usage point of view hence a very easy reading book and not heavy on the jargons of object oriented programming etc. I learned a lot of useful tricks after going through the book.



2. Outstanding reference and how to manual for Excel macro programming. A must have for anyone who has ambitions of writing their own programs for Excel. John's clear, organized, and comprehensible writing style allows even a novice programmer to immediately begin to write Excel macros that really do something, and do something useful. His book is chock full of useful code examples. Get two copies. It is that good.



3. This is a great manual for those who, at a minimum, have a limited knowledge of Visual Basic and a limited working knowledge of Excel. If you don't consider yourself an expert then this is the book for you!

   I've taught myself multiple computer languages (English is my natural language but that doesn't really matter now, does it?) and am very familiar with Excel -- but not so much on the programming side of things. As far as being a VB programmer, well, about two or three years ago I taught myself VB 5.0 and then never ended up needing to use it. The first time I used this book was to help me with a VB module in a customers Excel workbook. There was even an example in this book about using the Windows API to get the window to search for a directory which I was able to easily incorporate into the code. I then started reading through the chapters and just kept on learning more and more! When working on a project I can easily find a relevant chapter/section that pertains to what I'm doing or need and solve my problem!

   He clearly explains his code and if the example is a code snipet. The included CD contains his examples and other files which I find very helpful, especially when I don't want to type in everything myself :-)

   If you even *think* this may be a candidate for your library then stop thinking and just get it!




4. This book sucks! Its just a little better than the help file included in with Excel. All he does is put it in a diffrent order. I was expecting small excercises where I could put my new skills all together, but there is none. So you read the whole book, remember as much as you can, and go off and try to mix and match hundreds of commands... buy another one.



5. This book is oriented for those with basic knowledges of Excel and some general understanding of Visual Basic (Visual Basic 6 not Visual Basic .NET). However, the examples are simple, sequential and conductive for constructing basic applications even if you have never used Visual Basic before.
   
   Let the Author, Mr. John Walkenback, take you through the first 7 Chapters, type in the examples as you go, and you will rip the benefits.

1 comments about Systems and Software Verification: Model-Checking Techniques and Tools.

1. To be able to map a model onto the source code that implements it is a wonderful thing, as can be discerned from Berard's book. Because once this done, and he offers copious suggestions to this effect, then you can programmatically validate (ie. check) the source code.
   
   A relatively rare thing in computer programming. Mostly, verification is done in various manual steps, by programmer and tester. But by being able to structure a model as suggested by Berard, you get far more robust code. With high assurance of validity.

5 comments about Software Engineering: Theory and Practice (2nd Edition).

1. This book contains basic information and does not really elaborate beyond that premise. It's not bad but if you are looking for more detail and a little more substance, look for a different book. However, I really did not mind it for a start.



2. This is an excellent reference guide/course book that outlines the processes and issues involved in Software Engineering. The book offers practical examples and discusses "real world" issues. The book has a great website reference as well. Highly recommended.



3. If you HAVE to read this book, you'll know what I mean. The first time I read this book, I hated it... Boring, and one reviewer is right, it covers EVERYTHING under the sun about S/E. Now, after about two years or so, I keep finding myself refering to this book over and over again. I am liking more now that I see how and where to use the topics that it talks about. 4 star, b/c this book could have been written better. First time around was very boring.



4. This book is not worth buying for the following reasons:

   1) The book fails to explain the concepts clearly.
   2) It is rather confusing and boring; the chapters on important concepts are not clearly laid out. It seems the author hasn't given sufficient thoughts to come up with a better work.
   3) The book is full of grammatical mistakes.
   4) It total, it is complete waste of money in my view. There are many other good ones out there in the market on Software Engineering.

   Thanks,

   A Software Professional




5. when you're exposed to faulty education check out this book! this book will teach you from top to bottom what needs to be done...in theory. Moreover, it has sample cases and lots of procedures written by the authors themselves. For those majoring in Software engineering this is a must have!

5 comments about Constraint Processing (The Morgan Kaufmann Series in Artificial Intelligence).

1. This book covers both introductory and advanced material. It is a
   solid resource for introducing students to the basic mechanisms of
   Constraint Processing and for training the future generation of
   researchers in the field. It is also an invaluable tool for
   perfecting the knowledge of the seasoned researcher in topics beyond
   his/her particular expertise.

   Its coverage of the relationship between relational algebra and
   Constraint Satisfaction is unique and bound to inspire new synergies
   between Databases and Constraint Processing. The depth and rigor
   at which advanced topics are addressed (e.g., advanced consistency
   methods, tree decomposition techniques, and temporal reasoning
   networks) are a remarkable achievement, possible only given the wealth
   and significance of the author's own contributions to the field.

   This is one of those rare books you will enjoy reading over and over
   again, every time acquiring new knowledge.




2. This is the only book I found that contains almost all important results in the field. I have to refer to it from time to time.



3. This book includes the basics of constraint satisfaction that should appear in a textbook while in the same time presenting in a unifying manner important research results that constitute the state-of-the-art in the field. Diverse lines of research like tractable languages, constraint optimization, temporal CSPs etc are gathered in a single reference. The material is presented along with comprehensive examples. In my opinion this is an essential reference.



4. This book is a delight. Written by an expert in the field, it is useful to to various people, from beginner to advanced.
   
   "Constraint Processing" features a perfect balance between theory and practice, proving itself a valuable aid both in teaching and in production.



5. This is the most comprehensive book in the area of Constraint Processing (aka Constraint Solving and CSP) I have seen. It starts with the basics and takes the reader all the way to advanced topics. It is an excellent place to start if you want to learn the field. It is also an excellent reference for researchers and practitioners. I use this book frequently in my research and my work in the field of Formal Verification. The book is also of great value to those in Artificial Intelligence, Optimization, and Operation Research.

2 comments about SVG Programming: The Graphical Web.

1. Finally an SVG Bible for the Web. I have worked with SVG for just under 2 years and had to learn SVG from the W3C documents and lots of "experiments". I have only reviewed half of this book so far and found a wealth of knowledge on using SVG on the Web. It's examples are solid and well organized.

   This book can be used by the novice and the experienced to add the coolest vector graphics to their Website. This book is well balanced for all levels. It has earned a well respected slot next to my computer...




2. This book is head and shoulders above the Eissenberg book (O'Reilly). Kurt Cagle is a serious developer, and the book shows it, with advanced examples that explore all aspects of programming. It would have been nice to have a .zip file that had all the examples in it, but that's a minor nit.

2 comments about Introduction to Assembly Language Programming: For Pentium and RISC Processors (Texts in Computer Science).

1. Previously the books on Assembly I have read have been either 100 percent Intel syntax or have been based on DOS Debug, which is pretty antiquated. Reading this book introduced a number of new concepts and was for the most part an enjoyable read. First thing though, this book is designed as a textbook. While the book does cover the basic syntax in Assembly, I feel that it would be a difficult to read for a beginner who has not at least wet their feet in some form of assembly. It is definitely meant to be a book used in a classroom with an experienced facilitator covering the material. Being that it is a textbook, it does have nice exercises at the end of each chapter, if you can get passed the mental block of doing "homework", which are very helpful in understanding the material. The content of the book is very good. A detailed explanation of the different memory models used in the x86-programming model was very informative. I unfortunately did not get passed the Pentium processor programming, but I look forward to going over the MIPS processor when I get a chance and something to develop on.



2. The Pentium chip dominates the desktop, and this book reflects that. It teaches you the ideas in assembly programming, with a clear emphasis on doing so for the Pentium.
   
   Dandamudi also provides a concise summary of the history of the Pentium, going way back to the 8085 and 8080, around 1982. From these sprang the x86 family. All the way to the 486. But AMD's pesky nipping at the heels caused Intel to lose copyright to "586"; from which Pentium was chosen as the new copyrightable label. Alas, Intel never pushed "Sextium" but instead used "Pentium Pro".
   
   The book has copious examples of assembly code. These are extensively documented inline, to an extent that you will rarely see in most real code. The pedagogy should be clear to most readers. Who are also encouraged to try the problems provided in each chapter. Assembly programming is very different from coding in a higher language like C or Java, and it is a worthy skill to cultivate. And one that is independent of the actual processor family that you code in. If nothing else, the text gives you an underlying qualitative understanding of how higher languages are ultimately expressed in binary executables.
   
   I suppose I should say that there is also some coverage of alternative chip families in the book. Notably some RISC processors. These form a conceptually distinct approach to designing a microprocessor.

5 comments about Programming Windows Security (DevelopMentor Series).

1. I find this book amazing; it has the best of information i could find on this topic in one book.
   The topic on IIS and COM+ helped me learn a lot and taught me some design flaws i had in designing few apps for IIS.
   i would recommend every developer to have one in there shelf.



2. Keith Brown's book is a refreshing change from the 'stick in something about security in a side-bar' approach taken by so many authors. Finally a book which explains lucidly what amounts to a very complex topic; and does so in an understandable and enjoyable fashion. If there were 6 stars on the rating scale then it would get a 6...



3. This book does an excellent job of explaining Windows security at both the architectural and code levels. It's well written, even to the point of being entertaining at some points. Which is a lot to say for a security book.
   
   The book covers topics at a remarkable depth without feeling overwhelming. Though it's light on strict reference material (which is easily made up with the MSDN) it still has reference value because of the deep level at which subjects are covered. In particular, his coverage of network authentication is excellent. Which is fantastic because this is such a frustrating issue in practice.
   
   Definitely worth a look for anyone who wants to understand Windows security APIs at a deep level.



4. This is an excellent and well-written book on a topic that - sadly - shouldn't require a guide to be understood. The complexity and obscurity of Windows security APIs makes it somewhat of a futile attempt. But that doesn't mean you shouldn't be one of the few elite programmers who do comprehend it. In other words, highly recommended.



5. This book is a rare example of excellant background material and real world examples. The author's understanding of the intracacies of the Windows security model is unmatched. The writting style is easy to follow and even from time-to-time funny.
   
   The text is so chocked full of keen insights, I find something new everytime I re-read a chapter. If you're working on a project that requires understanding Windows Security (and what windows project doesn't), I strongly recommend you grab a copy of this book.
   
   There is only a single criticism I can make about this book, and that's about the binding. The cover is poorly attached stiff paper. After reading it a few times (ok, maybe a few dozen times...), the cover came off, and needed to be reattach (twice). The book now looks like it has been through a battle. For a reference text of this importance, hard cover binding would have been more appropriate.

5 comments about Logic and Language Models for Computer Science.

1. I have read the book and taken the class at George Mason University where he teaches and boy are there a lot of mistakes in the book. He should publish another book (the errata). If you are considering taking this class don't.



2. So far, my impression of this book is this. First, it's not very well written, and is often hard to understand. Concepts are not very well elaborated on. I'm having to go on the net to get better explanations... Second, I wish they would use more pictures for certain concepts, definately not a book for a visual learner. Honestly, I don't know why we are required to use this book for class, but I guess if I must, I'll use it. Professors should read this rating thing before they get these books... Hope this helps.



3. The book is very poor on examples and the ones that it has do not make any sense. Topics like automata and removing nondeterminisim are not explained well enough(only one non-sense example for nondeterminism). Awful diagrams. It is not going step by step to understand Prolog and Lex. In short, if you have choice don't buy the book and if you have bought it already, don't waste time reading it. Unfortunately, I had not other option, I have bought the book and am reading it.



4. This book is one the worst books I have used. I took this class with one of the authors and this book seems to be really lacking and so does the author when it comes to teaching. Get something better. But you will probably be stuck with having to get this for the course since the homeworks are from this book.



5. If you are looking for a cookbook or picture book approach or googled snippet of information this is not the book for you. What you will find is a book written with logical clarity usually missing in computer science and discrete math books. If you like to think logically and understand a topic instead of just memorizing it and if you are interested in the role of abstraction, logic and proofs in computer science, this is the book for you.