5 comments about Eclipse Cookbook.

1. 
   Prof. Steve Holzner is an authority in Java and has many books to his credit. Prof. Holzner's
   
   expertise and patience is well brought in this book with adequate explanation of the different aspects
   
   of Eclipse.
   
   The book is full of screen prints that adequately explain how the screen would look while using the
   
   built-in features of eclipse. the author has taken the time to take different scenarios and ways to
   
   work around the different problems encountered while using the tool to develop Java applications. to
   
   demonstrate some of the features, the author debugs a sample program and identifies the errors
   
   commonly encountered and ways to resolve the errors.
   
   as mentioned at the beginning book, this book does not intend to teach programming aspects of Java but
   
   the features and the nuances built in the tool. The author has taken the time to explain how the
   
   tool integrates with ANT and TOMCAT.
   
   although this book was written with Eclipse 2.x, the author indicates the features that would be built
   
   in eclipse 3.x. the author's style is simple and straight to the point. it is a well written book
   
   and an excellent reference on eclipse 3.0. the book has earned a place in my shelf.



2. A recent addition to my Eclipse library has been Eclipse Cookbook by Steve Holzner (O'Reilly). It works well for my level of expertise at the package, but experienced users might find it lacking...
   
   Chapter list: Basic Skills; Using Eclipse; Java Development; Refactoring, Building, and Launching; Testing and Debugging; Using Eclipse in Teams; Eclipse and Ant; SWT: Text, Buttons, Lists and Nonretangular Windows; SWT: Dialogs, Toolbars, Menus, and More; SWT: Coolbars, Tab Folders; Trees, and Browsers; JSP, Servlets, and Eclipse; Creating Plug-ins: Extension Points, Actions, and Menus; Creating Plug-ins: Wizards, Editors, and Views; Index
   
   Like all O'Reilly cookbooks, this follows the standard formula. A problem is presented, a short two or three line solution is given, and then there's a discussion and fuller explanation of the answer. There are plenty of screen shots and coding examples to help you through each of the recipes.
   
   Overall, the book will benefit new and intermediate users. The author covers quite a few of the features of Eclipse that make it so powerful, like refactoring, running the debugger, and other various tasks. You may know that these exist but not know how to use them, or you just may be ignorant of the fact that they even exist. In that sense, it's really good. The SWT portion seems to be more centered on programming with Eclipse as a secondary focus. Maybe because it's because I don't do SWT development, but it just seemed to be a bit out of place. The material also seems to be pretty basic for a cookbook. Usually the recipes are more beyond the basics and get into things that aren't quite as intuitive as they might be.
   
   This will help me get up to speed on Eclipse, and I do like the book. I'm just not sure it's for everyone...



3. After getting used to the fundamentals of the Java programming language, a versatile integrated development environment like Eclipse would bring developers to next level of productivity, and Eclipse Cookbook is handy for the start. Readers are guided step-by-step with numerous illustrations about its support for tasks from creating packages, classes, methods to refactoring, and debugging. The book demonstrates Eclipse 2.1.2 with the difference of early release of version 3.0 being mentioned. Now when versions 3.0.1 and 3.1M are readily available, you might need to resort to online help for the exact updated steps. You will find the use of application programming interface of platform dependent SWT for building GUI with both AWT and Swing being mixed. However, it gets nothing to do with the drag-and-drop style of building graphical components. Web development is included but too concise. No elaborated features like performance profiling or modeling tool of round-trip development are described. Perhaps it would be more appropriate to introduce to target audience with various commonly referred plug-ins on tasks like integrating with different kinds of version control, validating XML, modeling UML, and J2EE support.



4. The book has some useful information, but does not
   go beyond the very basic. In light of this, it is
   annoying that so much space is taken up with repeated
   samples of the same code, and with more screen shots
   than are needed. I've encountered this before in one
   of Mr. Holzner's books (XML Complete), and I have to
   wonder if this is done to pad the book to a length
   that justifies the cost.



5. I was use to using a much simpler editor for writing Java code. This book did a very good job helping with learning how to use Eclipse.

2 comments about JavaScript(TM) Step by Step.

1. This book was a great for a beginner to Java Script. The exercises were easy to follow and were relevant to real world problems that you may need to solve. The author keeps things lite and keeps the material interesting. Not only is this written for beginners with little to no programing experience (like me) but I can definitely see coming back to this book as a reference as I continue developing with Java Script!



2. I'll agree with Chris from Minneapolis. This is a great book no matter what level of scripting experience you have. I had/have very little java scripting experience and with this book, it's very simple to learn in a fashion that is geared more toward real-life situations, vs. just some script that a professor or teacher wants you to write that has no meaning besides giving you work to do. GREAT BOOK, RECOMMENDED TO ANYONE OF ANY LEVEL OF SCRIPTING EXPERIENCE!

5 comments about The JavaScript Anthology: 101 Essential Tips, Tricks & Hacks.

1. It is a good book with useful tips and tricks.
   the authors use an elegant way to catch the target.



2. I didn't really think I needed this book -- I have sever other JavaScript books, including the O'Reilly JavaScript Cookbook, and it seemed like this would just be a duplication. But I kept reading really positive reviews of this and other SitePoint books on sites that I trusted, so I decided to take a flier on it.
   
   I'm really glad I did. Unlike some of the O'Reilly books, which are dated at this point, this has really up-to-date, professional code that incorporates best practices. Depending on what kind of JavaScript code base you need to integrate with, you may be able to use this code as-is in many instances. Even if you need to modify it for your own uses, you will never find poorly-organized hackwork here.
   
   Also nice is the up-to-date topic selection. Classics like DOM, form validation, drop-down menus, and cookies are supplemented with topics about accessibility, XMLHttpRequest, in-page dialogs, and using class prototypes. When the authors tell you how to launch popups, they also tell you about all the pitfalls and problems.
   
   No cookbook is going to cover ever possible topic (personally, I would have liked to see JSON examples), but this one is about as complete as you could reasonably ask for. Really, the only downside about this book that I can see is that you need to have at least an intermediate understanding of JavaScript to understand what's going on. There isn't a lot of handholding, and you will likely want to own both a good tutorial and a solid reference on JavaScript and spend some time with them before you're ready for this book. But if you have a good working knowledge of JavaScript and are looking for practical, well-written examples of how to incorporate new techniques into your code, you won't find a better book than this one.



3. This is an excellent next-step up from an introduction to Javascript and looks at its use in real world situations. You will need to be reasonably fluent in the language to get the best out of it.
   
   The book presents a topic as a question and then presents code to action that query as a solution, then goes through that code in a discussion section. This is where I have a relatively minor criticism of this book; the necessities of discussing the code do not always mesh well with the question and answer format of the layout.
   
   The authors have gone to great effort to ensure that the book is as up-to-date as possible, though this is a rapidly moving target of course, and detail how to ensure that the code will run on as many platforms as possible, rarely giving up and saying 'forget it..', though this proved necessary in a number of the more esoteric options and older browsers.
   
   A highly recommended read if you are looking for a quick solution, or a detailed understanding of what's going on.



4. I purchased this book out of desperation after using a 1000 page Javascript Wrox book published in 2000 that was worse than useless. The author's blog posting here is very accurate: it is a modern javascript book that gives usable solutions and concepts that work well. I recommend this book to anyone who has at least some programming background and is sick of cut and pasting garbage code from other mickey mouse tutorial sites that break at the slightest change. It is also a great start for working with AJAX, which is what I needed it for.
   
   That said, the book is surprisingly a great read. I am reading this book cover to cover and also use it as an every day reference with dozens of tips. It is obvious the authors have worked extensively with web sites and write from experience. Thanks for a job well done!



5. I should preface my review by saying that I generally love the sitepoint books. Simply Javascript (also co-authored by Adams) is hands down the best programming book I've ever read. That said, this book isn't really so much a "book" as it is a "handy reference." If you skim this book and find something you need, then you may be able to justify the cost. As a cover-to-cover read, it's definitely lacking and will leave you wanting. Taken as individual chapters, the writing is excellent and the solutions offer solid coding practices. My recommendation would be to find this book in a bookstore, skim the table of contents and chapters, and see if you will actually use any of the included solutions before you buy.

5 comments about Java Developer's Guide to Eclipse, The (2nd Edition).

1. The book is very good. The problem is the examples. The examples are all heavily loaded and compounded. Like when you want to learn a certain type of a tree, instead you will be put into a dense forest and lost totally. I do not recomend the beginner to start with this book. I want the author to redesign the examples so that the topic be focused.



2. The book composes of 6 parts.
   
   Part 1 fouces on how to use the Eclipse IDE. The authors do a good job in explaining how to use the Eclipse IDE. Once a while, you will pick up some tricks that you will find extremely useful. Unfortunately, it also explains things that seems obvious from the UI perspective. In short, you read through 10 lines to get one line of useful information.
   
   Part 6 are the exercises that illustrates some simple concepts discussed in the previous section. That part does a pretty good job also.
   
   The other 4 parts discuss how to extend Eclips IDE and to write Rich Client application. Unfortunately, the authors fail miserable in organizing the information. I am expecting the authors will first explain the basic concepts and then start with some simple application and then build on that.
   
   Unfortunately, the first few chapters in those parts does a very poor job to give you a comprehensive overview. Then the authors will get into details that will make you completely lost. The worst part is that when they are getting into details, the section will fill with a lot of "forward looking" statements like do not worry about some details which will explain in later chapter. Sometimes, you will find that if they reverse the order of the chapters, it may be easier for you to understand.
   
   This book definitely needs a better Editor to make the information more coherent, and to condense the information better. The authors should re-organize the chapters/information to start from building a simple application with a window compose of a few views and some manual items.



3. Like many others I wanted to extend Eclipse so I can be more productive. Unfortunately I found this book to be poorly written and the technical details vague. I know what I want to do, but the book (over 1000 pages) does not show me how?!
   
   It explains the Eclipse architecture and idea goals which is fine but is repeated over and over again in various chapters of the book. I also could not get a handle on how it can be applied. This is not a practical guide to Eclipse. It is more about Eclipse's internal design which for most people is a waste of time. The online documents are more useful.
   
   Note the book is also out of date. I tried to follow some of their sparse examples, but I quickly realized it's a waste of time because I have the latest Eclipse 3.11 installed and the examples were for Eclipse 3.0 and the menu options and API have changed. All in all, this book was a real let down.



4. The first edition was simply great. Not only that it was the first book to describe how to write an Eclipse plugin, it still would be the best -- if Eclipse had stand still. The second edition is not too bad. But the chapter on writing a text editor plugin is so superficial that it could have been left out. Where the first edition described in (necessary detail) how to write a text editor plugin, the second edition just roughly describes the concepts, but no API usage, no example in the book's text. The code on the accompanying CD is somewhat better, but now (2006) partially out of date as well. So if you want to write a text editor, there currently is no book or article I am aware of, that really helps you. You have to dig through existing code and try to find out for youself, why things are as they are.
   
   Finally, the first part of the book on how to use Eclipse could have been removed (~20% of the book) and the chapters on how to write plugins should have been enhanced.



5. The reason this book gets both great and lousy reviews is that Eclipse is such a huge subject. The writing of Eclipse plug-ins is simply a larger subject than any reasonable book can cover. If the topics that the authors chose to cover happen to align with the ones you personally need, then the book is excellent, but if they don't align, the book isn't going to help you much. Part I (six chapters) covers using Eclipse to write programs. Part II (seven chapters) covers the fundamentals of Extending Eclipse with plug-ins. Part III (9 chapters) covers plug-ins in more depth. Part IV (5 chapters) covers extending Eclipse with new tools for the IDE. Part V (6 chapters) covers assorted extra topics, such as OLE and Active X integration and performance tuning. Part VI is a set of nine farily detailed exercises (with source code on the provided CD).
   
   This book is not an overview, the authors opted instead to cover certain topics in pretty good depth. This aproach is good for those already aware of the basic concepts, but will be confusing for noobies (which I was when I first got it). I suggest that those new to Eclipse plug-in development start with a good overview (such as _Eclipse 3 for Java Developers_ by Daum) before switching over to this book for more detailed descriptions.
   
   This book doesn't cover the Eclipse Modeling Framework or the Eclipse Graphical Editing Framework, probably because each of these is a book in itself. This book is also light on its coverage of SWT and JFace, which you will need to be familiar with to develop your own plug-ins (again, a book-length subject in its own right). You will also want to be thoroughly familiar with Java Design Patterns and best practices, since Eclipse uses practically every design pattern you've ever heard of.
   
   While there have been changes to Eclipse since the Second Edtion came out, I was able to figure it out and map between the examples in the book and Eclipse 3.2.1 without too much trouble.

5 comments about JUnit Recipes: Practical Methods for Programmer Testing.

1. This review also appears on StickyMinds at http://www.stickyminds.com/s.asp?F=S767_BOOK_4
   
   JUnit Recipes is a comprehensive tome of practical methods and techniques for the opensource JUnit tool to develop automated unit-tests for Java/J2EE applications. The book is split into four parts: Building Blocks, Testing J2EE, Additional JUnit Techniques, and Appendices. The Building Blocks cover the basics of using JUnit to create basic tests, organize and manage test suites and test data, running JUnit tests and reporting the results. It even includes a section on troubleshooting. Testing J2EE covers XML, JDBC, EJB, web components (including JSPs), and J2EE applications. Additional techniques include testing some well known design patterns, using JUnit add-ons and JUnit libraries (like GSBase). The Appendices include complete solutions (including code of course), some short and sweet essays on testing, and a modest recommended reading list.
   
   The organization of the book flows very logically and the writing style is very clear and easy to follow. Along the way many insights into important design principles and testing techniques are revealed: the reader will learn about the "Hollywood principle", the Open-Closed principle, design patterns, POJOs, Mock Objects, Private and Parameterized Test-Cases, Abstract Test-Cases, Self-Shunts, and Spys. The book's coverage is very comprehensive and touches on many other popular Java/Enterprise projects and frameworks such as Struts, JBOSS, Prevayler, XDoclet, Tomcat, XPath, XMLUnit, HTTPUnit, Ant, Jakarta, and others.
   
   Even though JUnit is often associated with "Agile" development and much of the wisdom apparent in the book applies to agile Java development, the book is useful to any Java developer on any Java project (agile or otherwise). The book also goes into considerable detail, with working code examples, to spell out exactly how to perform and apply the techniques it describes.
   
   The book's primary audience is Java developers. Java Tester's will still find some good nuggets of information but it's quite clear that Java programmers and developers are the target audience. This isn't some high-level theoretical book mostly of concepts and ideas. This is an imminently pragmatic guide that not only conveys a great deal of highly practical wisdom but also clearly and comprehensively walks you through the explanations and the code to accomplish and apply the techniques it describes. The book is also not a "How To" for coming up-to-speed on setting up and running JUnit.
   
   Another book from the same publisher, "JUnit in Action" is a great overview on learning more about the basics of running and using JUnit and on using JUnit to tackle a number of basic challenges with unit-testing Java and J2EE code. JUnit Recipes has some overlapping material but pretty much "picks up" where "JUnit in Action" leaves off, and JUnit Recipes goes into much more breadth and depth of coverage of JUnit methods, practices and techniques and use with other Java projects and frameworks.
   
   I would say JUnit Recipes should probably be required reading for anyone attempting to use Java, J2EE and JUnit in the real-world.



2. This isn't necessarily the best introduction for absolute beginners (I would recommend /Pragmatic Unit Testing/ for that), but it is required reading for server-side Java, as most other reviewers have pointed out. But it's more than that--it's one of those rare computer books that transcends its subject matter. Why? Because it can make you a better programmer. While some of the credit can rightly be given to unit testing and Test-Driven Development in general, Rainsberger's book makes you /see/ better ways to write and refactor your code. The breadth and depth of examples is astonishing--he convincingly shatters "but it's too hard to test that" arguments with well-researched, non-trivial examples. In fact, I'd say that this is almost a better J2EE tutorial than most books about J2EE proper.
   
   I'm withholding a star for one reason: the book doesn't cover GUI testing tools like Jemmy, JFCUnit, or Abbot/Costello. These JUnit extensions are ripe for a book with this depth; it's just too bad that this couldn't be that book. Other than that, I find that I turn to Rainsberger's book far more often than any other testing book or online reference.



3. Rainsberger does a very good job of detailing the techniques to unit test difficult code; including xml, ejb, servlets, jsps etc.



4. This is a great book. It is directed at users of JUnit, the Java unit testing framework. But in my mind the book gives sound advice for solving your programming problems in general, not just for Java or JUnit testing. It stresses the importance of unit testing, programming to interfaces instead of implementations and just simple common sense. The author is clearly passionate about his field and extremely experiences. The combination of enthusiasm and experience comes through on every page.



5. This is a readable, practical, and deep book. It's one of those books which teaches or refreshes Java and OO theory and practice as you read. I am also reading it for pleasure!

4 comments about Quartz Job Scheduling Framework: Building Open Source Enterprise Applications.

1. One of the things I appreciate about working with Notes/Domino is the ability to schedule agents to run on certain events or on a schedule. But I always wondered how I might accomplish the same thing if I had stand-alone Java applications? This appears to be the answer... Quartz Job Scheduling Framework - Building Open Source Enterprise Applications by Chuck Cavaness.
   
   Contents: Scheduling In The Enterprise; Getting Started With Quartz; Hello, Quartz; Scheduling Jobs; Cron Triggers And More; JobStores and Persistence; Implementing Quartz Listeners; Using Quartz Plug-Ins; Using Quartz Remotely; Using Quartz With J2EE; Clustering Quartz; Quartz Cookbook; Quartz And Web Applications; Using Quartz With Workflow; Quartz Configuration Reference; Index
   
   Quartz is an open source Java-based scheduling package and API that allows you to build programs that control other programs and events. For instance, let's say you have a Java program that reads a directory, parses any XML files in that directory into some format, and then writes the results to another directory. You could have someone do that manually every couple of hours, but that's a waste of time. Quartz allows you to write the program such that it will run automatically on schedule, freeing you from manual intervention. It uses both event triggers and cron-style scheduling commands that allow you to get very creative in your requirements. The best thing is, it's an open source project that has wide support in the industry and an established foundation of experience to draw upon. Cavaness does an excellent job in leading the reader through the concepts of job scheduling, through basic Quartz jobs, and finally into a full understanding of what Quartz can accomplish.
   
   This is the type of gem that makes book reviewing important to me. I had no concept of this particular type of program, and now I have an entire new set of ideas to draw from. While I don't have a particular need for this immediately, I'll be keeping this book around because I can see it filling a definite need without too much effort. A very nice read...



2. Good book. Tells you what you need to know.



3. I bought this book hoping for some in-depth coverage of Quartz' more subtle features and gotchas. One particular thing I was hoping to get more coverage on is pausing and resuming triggers, and the side-effects of doing so (the JavaDoc is mute on this point). Well, pausing triggers is not covered at all. Nothing else in the book seems deeper than the JavaDoc or the Quartz site, so I'm glad I didn't pay full price. At least a book is useful to take along somewhere to read, as opposed to having to be online.



4. Good book, but the back cover leads you to believe that there is a section on Hibernate. There is no information about configuring Quartz and Hibernate inside of this book, and that was the reason I bought it... No mention of Hibernate at all, except on the back cover.

2 comments about Pro Netbeans IDE 6 Rich Client Platform Edition (Expert's Voice in Java).

1. I've bought this book hoping that it'll help me use the "platform", i.e. a set of reusable components that Netbeans itself is built with, to write my own app.
   
   Instead the book is basically a shrunk paper based version of the Netbean's own help.
   
   Absolutely worthless. Definitely returning it.



2. Eagerly anticpated book that was utterly disappointing. I had decided to make Net Beans my IDE of choice, but because of the lack of good documentation (including this book) I am going back to [...]

5 comments about Oracle Database Programming Using Java and Web Services.

1. I have been working on different projects building enterprise level software involving many J2EE and Database technologies. One of the major frustration facing developers is how "practical information" related to these two worlds are completely isolated from one another, in fact, it is very common to see the majority of today's developers specializing in one of them and completely ignoring the other. The few who actually can keep following up with both can understand and achieve a lot more.
   I found the information in this book to be complete; it describes the notions, the architectures (even those details that are hard to find anywhere) and it gives detailed examples on how it will look like in the code which cuts learning time for engineers a lot.



2. If you use Java and/or Oracle (Or if only you've planned to), this is THE book you miss ! Complete and easy to read, every concept comes with samples and scripts. Full of informations that I didn't find anywhere else, I've learned a lot. When it talks about something I already knows, it does it so well : "There is probably no better ways to explain things".



3. I've been programming in C++, Corba and Java for years and was looking for a book to develop agaisnt the Oracle database. First of all this book is well written and at a glance, it covers all the API and utilities that a Java developer may use to exploit the Oracle database including Java in the database, JDBC, SQLJ, JPublisher and Database Web services ( Corba folks like myself will love the Web services part). You will be amazed reading through this book all the possibilities that Java in the database allows ; the Groovy and Jython stored procedures are just well presented. I am right now digging into Part-II dedicated to JDBC, the Rowset API, RAC support, etc. This book will provide great career advancement opportunities. I strongly recommend this book to my Java developers fellows.



4. This book has a good deal of information that is accessible. However, several coding examples are incomplete and in some cases misleading. Given the strengths of the book, they are probably oversights or space limitations. The missing code segments are too frequently in the wrong places.
   
   The code examples predominate the book. Hidden gems are nested where readers only find them searching out topics. On a bright note, the index is good at locating what is in the book.



5. I've been doing Oracle database-related application design and development since before Java even existed. As time progressed, Java became more and more prevalent in the Enterprise environment, web servers became application servers, and before you knew it, Java was being run right in the database.
   
   It has always been difficult and confusing to figure out the various Java technologies and tools and implementations when it comes to a complete Enterprise system... until now.
   
   Kuassi does a remarkable job of providing keen and detailed insight into all aspects of Java in the Oracle Database realm.
   
   A nice, logical technical progression as well as very detailed code samples make this book useful for those wishing to introduce themselves to the basic concepts, or write a specific implementation.
   
   The detailed case studies that show real code used in real world solutions are invaluable. (We've already implemented one of them for a new project we're starting on!)
   
   All in all, it's an excellent book and should be on the shelf of any DBA/Developer that has anything to do with Java in their environment.

5 comments about Test-Driven Development: A Practical Guide (The Coad Series).

1. 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.




2. 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.




3. (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.




4. 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!



5. 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.

No comments about Modern Software Development Using Java, Second Edition.