5 comments about Practical Subversion, Second Edition (Expert's Voice in Open Source).

1. The second edition of Practical Subversion has been updated, but not substantially changed. The new edition has somewhat higher production quality and editing. The reference material on the various svn subcommands has been updated to be more current. This is very important because the first edition was badly out-of-date in this area.
   
   The book has many good features, such as the "Best Practices" chapter, the comparison of Subversion against other version control systems. and the API documentation. These sections have been cleaned up and, in a few cases, extended to provide a real benefit to the reader.
   
   Unfortunately, I don't think the book went far enough with the practical "guide" content. More information about how to use version control and the special features of Subversion in particular would have been a better use of space than repeating the reference material that can be had freely on-line.
   
   Like the first edition, this book tries to be both a solid reference and a practical guide. Unfortunately, the authors do not separate these two missions in the book. This leads to a kind of split personality, where the practical advice is interrupted by reference material and vice versa. I found this to be a bit distracting, and think it prevents this from being a great book.
   
   That being said, this is a good book that covers Subversion quite well. I have recommended it to people already on the strength of the "Best Practices" chapter alone. If you are using Subversion, the practical usage information in this book should help you make better use of the tool.If you are considering using Subversion, the comparison of Subversion against other tools is a very important resource.
   
   Although I think the structure of the book could be improved, I still don't mind recommending the book.



2. The version control system known as Subversion is quickly taking over the title of open source leader from the old standby, CVS. If you already have some background knowledge in version control systems and you want to start using Subversion, the book Practical Subversion (Second Edition) by Daniel Berlin and Garrett Rooney would be a good way to transition yourself over...
   
   Contents:
   Introducing Subversion; A Crash Course in Subversion; Repository Administration; Migrating from Other Version Control Systems; Advanced Apache Integration; Best Practices; Integrating Subversion with Other Tools; Using the Subversion APIs; Subversion Command Glossary; Subversion Compared to Other Version Control Systems; Index
   
   Unlike some books that cover version control systems (either generally or one in particular), this one doesn't try and take you from ground zero to expert. While there is some background material, the overall tone is one that assumes you are functionally literate on the subject and are particularly interested in Subversion. While that might limit the potential audience a bit, it makes it much more focused and valuable for those who want to bypass entry level material. The chapters cover both administrative and user-based functions, but tend to be a bit more heavy on the setup and administration end. For something that could be a rather dry subject, the authors do a good job in keeping things moving forward and interesting. I also found the chapter on version control system comparison to be valuable. All systems are *not* the same, and there are some underlying structural differences that will have a significant impact on what does and doesn't convert over, should you choose to switch systems.
   
   All in all, a good book on Subversion, and one that will get you started in the right direction.



3. _Practical Subversion_ seems to have a theme that distinguishes it
   from "the" Subversion book at [...]
   integration. Looking over the table of contents, i see that 5 out of
   the 8 chapters focus on integration of one kind or another.
   
   After the requisite chapter on installation, the book moves quickly
   through "A Crash Course in Subversion" and "Repository Administration"
   and then on to the good stuff. These first three chapters are
   thorough and adequate, but are basically the same as such chapters in
   other books about Subversion. It's almost a shame such chapters have
   to be included, as they're only useful during a short period at the
   start of the book's life on your shelf.
   
   _Practical Subversion_ really starts to shine in the chapter on
   migration from other systems; it even documents the dump file format!
   It goes on to document Apache integration; repository browsers;
   integration with the shell, Emacs, and Ant; and closes with an
   excellent introduction to the Subversion APIs.
   
   Overall, this is a great book for using Subversion in practice. It
   lives up to its title.
   
   --Eric Gillespie



4. The "practical" in the title must refer to sysadmins, developers, tool integrators, and the like. If you are just someone that wants to become very proficient *using* svn, you, as I have, will find this book most *impractical*. The "crash course" chapter only begins to meet a user's needs, but it stops way short. The book then goes on to treat in detail a host of topics that as a user I could not care less about. Usually, I wind up having google for what I need -- I am currently looking for a better user's svn book.



5. I like this book. It does a good job describing the how to use subversion and many of the industry standard ways subversion is implemented. There are lots of easy to follow examples and good hints of which direction to take when there is an implementation "fork in the road" (i.e. BDB vs FSFS).
   
   The book also does a great job showing you the difference between other version control systems... mostly CVS.
   
   My only gripe with this and other Apress books is that they usually include a section on IDE integration.. This is a good idea but they usually only cover Eclipse and not Netbeans... this book is even more annoying in that it includes Visual Studio(!!!) and not Netbeans... Granted, Subversion integrates pretty easy with Netbeans but geez.. Include the 1/2 a page so all major IDEs are covered.
   
   Done with my rant. Beyond that, I really like this book. I feel this will get you going with Subversion. In a few days of reading, I had enough information to properly setup my own server.

5 comments about Database Processing: Fundamentals, Design, and Implementation, Ninth Edition.

1. I use this book to teach database course as part of information systems management program. The update to the 9th edition is a big relief to me since it makes considerable improvement from the 8th edition, though I still feel disappointed time by time during my preparation and teaching. The 9th edition perhaps is a quick fix to the 8th edition and a lot remain to be corrected or improved.
   
   First, let me discuss some of the strengths of this book as textbook. This book covers not only relational database itself, but also the database applications, which is essential to build an in-depth understanding of database technology. It covers managing Oracle and SQL Server in two separate chapters, which makes it easier for instructors to tailor the book. It has extensive coverage of database access technologies that enhance the understanding of database processing if the presentation of such material is improved.
   
   This book does contain quite a few vague and confusing discussions on some important issues and concepts, even to subjects as basic as entity, entity class and entity instance. This makes the book sometimes difficult for beginners and students and irritating for experienced practionaers.
   
   In my opinion, the author sometimes deliver material without enough consideration of the course flow or the style of the book. For instance, the discussion of the synthesis of relations is in a very different tone from the rest of the book. There are many occations like this one that cause this book unnecessary difficult to read. Though the book has devoted entire two chapters to Oracle and SQL Server, it fails to provide an adequate coverage of database industry, vendors and products. It does not provide good overview for the architectures Oracle and SQL Server, either.
   
   Upon reading and teaching this textbook, I have the impression that the author often fails to deliver adequate and correct discussions of many of the contemporary technologies widely used in the industry. For instance, the discussion of database access technologies contains many incomplete and incorrect statements. Often efforts are made more to unnecessary details other than important concepts. Apparently the author is teaching us something that he does not understand well.
   
   Some of the newly added contents are not very well designed and organized. Part V is titled Database Access Standards. I do not understand why Chapter 14, with subjects such as OLAP, data warehouse, data administration, is placed as a chapter here. I do not understand either why the author does not consider XML be a part of Chapter 14. I believe the author should also cover data integration in this chapter. Though the author spends 3 chapters to discuss database access technology, I feel most of the efforts are devoted to lengthy and poor-written ASP/VBScript, and JSP codes that do not help much to the understanding of the concepts and should be covered by other books and courses. Surprisingly, the author does not cover multi-tier architecture. For me, merely one chapter to cover the latest client/server and Internet architectures, as well as the various data access layer implementations, including the conceptual coverage of the contemporary database access technologies such as ODBC, OLE DB, ADO, ADO.Net, JDBC, and object-relational mapping, will achieve more. I also suggest the author to enhance significantly the coverage for Chapter 14, since OLAP, data warehouse and data management and database administration are fundamental for database processing course. I believe the author should at least dedicate one chapter to OLAP, considering that fact that he wrote 3 chapters for database access technology alone.
   
   Overall, I feel the database coverage of this text is far more professional than the database applications part, though I still hope he will do a better job next time for the database part.
   
   At the website of the publisher of this book, it states that this book is "For undergraduate courses in Database Design, Introduction to Database Processing, Database Management and Design in departments of Business, Information Systems and Applied Computer Science". However, The book description of Amazon.com suggests that this book is "For database administrators, database designers, application programmers, or other professionals in the field who want a complete, up-to-date, easy-to-use database book". Of course, this is an almost impoosible mission. My opinion is that this book is for school study, provided you have an experienced and good instructor who may clarify the many issues that the author misrepresented or not explain well.
   
   /* The statement and opinions expresses here are my own and do not necessarily represent those of my employer */



2. This book was used in the Data Modeling course I just finished and it was an excellent choice. Kroenke's book came bundled with oracle 9i, but I think that the ERwin data modeling tool should also be included in future editions. The use of the book along with Oracle and Computer Associates' ERwin made my study of Data Modeling very enjoyable.
   In response to some of the negative reviews, it is my belief that the student should have a previous exposure to Relational Databases before attempting to read this book. Therefore, to use this book as an introductory course might be a bit much for the novice.



3. Without question, this is the most obscenely overpriced and worthless book I've ever bought.



4. There is a problem in the IT learning experience that surrounds textbooks. The problem is that their is not a logical learning path to follow to obtain the prerequisite knowledge to progress in the field. Data structures and Discrete Math are two prime examples of this. Its not like traditional math where you take Alg1 then Alg2 College Alg...etc....Its more like boom here it is with Discrete. Anyhow, I have been over many textbooks in IT and this is the problem. IT authors are either way too indepth and write textbooks that are practically impossible to understand or...??? Well in lots of cases there is no alternative. Database texts are no exception. I studied Conelly/Begg's "Database Systems" and found that to be an exceptional book for Intermediate level study, however it lacked any systematic learning approach. Its more encyclopedic and detailed than what is needed in a first course. Thats the problem with learning from IT texts. We are forced to learn from texts that are written from a high level non-structured format in entry level courses where structured learning is most critical. So how do we learn and progress when this is the case...answer: you dont...its a weed out. LOL? Anyhow, look at the title, it says FUNDAMENTALS! Then look up the word in the dictionary if you dont know what this means as it seems that some people in the IT teaching/learning world dont understand this word! Kroenke writes this book as an entry level, basic, introductory and FUNDAMENTAL course in database processing. After understanding these basics then you can move on to Intermediate and more Advanced Database courses. Thats what the IT teaching and learning experience is lacking. A Progressive structured learning format with texts written with appropriate titles which is seldom the case! Kroenke does this however as the title suggests. The text is progressive and structured and teaches the FUNDAMENTALS! Hopefully the textbook teaching world will evolve from the dark ages and professors will start writing texts in a progress oriented format in order to make the learning process more efficient and effective. Hmm..maybe thats why we are losing out to other countries, they teach this stuff more effectively? In brief conclusion, although this text isnt perfect, Kroenke provides what many of us are really looking for; to learn the basics of database technology. Thanks Mr. Kroenke!



5. I'm a beginning db student, and this book is bad. Really bad. I'll just pick a few words that describe my experience with it: verbose, awkward, vague, anguishing...
   Mine is now filled with handwritten corrections that our professor helped us add (I can't believe how many typos slipped through editing). Our whole class pretty much agrees that this book still needs some serious work before it could be considered publishing material.
   The university department chose this book based on Kroenke's excellent teaching and database reputation. However, it seems that he really has no idea of how to put together a good book.
   Something criticized in other reviews is the text's layout. I agree--it's horrendous. You are often reading about a diagram two pages back, or one page ahead. In fact, I'd say that, more often than not, when the illustrations are referenced, it is on a totally separate page. (Did that make sense?) Example: "Figure 4-5a shows how......." So you'll have to flip two pages back to see the illustration.
   Ugh! I normally love learning, but I really have to force myself to trudge through this drivel.

4 comments about Professional Software Testing with Visual Studio 2005 Team System: Tools for Software Developers and Test Engineers (Programmer to Programmer).

1. What a fantastic book!! It has helped my software developers and test engineers to better utilize all the tools available to them! The authors are articulate and knowledgeable of the subject. Highly reccomended late night reading!!



2. Some coders may turn away from this book because it has "testing" in the title. Some test engineers who don't code may also waffle when they see source code examples written in C# included in the book.
   
   This book truly caters to both programmers (developers and technical testers: unit testing, code coverage, dynamic analysis, static analysis / fx cop, profiling, unit testing against a database, data-driven testing, build verification testing) as well as testers without a programming background (recorded web testing, load testing, manual testing, test library management).
   
   Because the line between programmer and tester becomes more difficult to define -- especially with today's software test engineers who are also hard core coders and developers who write their own test suites -- this book provides everything the programmer needs as well as everything the test engineer needs when looking to get started and utilize the incredible set of tools the team at Microsoft added into Visual Studio Team System.
   
   (This book also explores how these tools are integrated into Team Foundation Server (including check-in policies, automated testing of builds, associating bugs and tests, and more) -- so in many cases, this book not only applies to testers and developers, it will also be of interest to technical program / project managers, dev managers and test managers).



3. The previous reviews I read about this book gave great praise. And all that they said is true, the book is well written, clear, concise, and easy to understand - with rich wonderful hands on examples and source code. A wonderful entry into the Microsoft offerings of testing right along with software development.
   
   What makes this an even better buy or value added product is that if there is an issue with why things work (or don't work the way they should) the author(s) will follow up with you in an attempt to clear up any misunderstandings.
   
   Not only is it a very good read, the authors can and do add additional value to the book long after it has been paid for - should there be any questions upon anything contained in the text - something that is very unusual in this realm or domain. I can not say enough about the quality of this book and the quality of the service one gets should they have a need to contact one of the authors - in my case it was Andy Leonard - who kept helping with something that wasn't even his issue - it was one of those undocumented Microsoft "features".



4. Precondition: I also went through chapters 1 to 4, for my interest was in Database testing.
   Pro: This is a nice intro into testing databases using VSTS, the only product that I know does that. If you want to see some bits of what can be done using this instrument - go for it. A piece on enhancing built-in functionality with recordsets counter is definitely a nice one - a must-read for anyone who wants to do more realistic testing than what MS offers out of the box!
   Contra: I expected to see how to construct a solid framework for testing industrial-scale applications but failed short of it. Namely, I could not find the discussion of how to set up the whole facilities, how to run tests as a batch from outside the Studio - our SCM/Build Team does not open Visual Studio to run their operations overnight, you see. I could not find detailed discussion of Pre/Post events, yet this seems to be absolutely essential for any serious testing: you need to have some known state of DB before you run your tests and you should be able to restore that state (efficiently, so backup/restore of multi-Gig DBs is not a viable option) to run other tests (DB and non-DB).
   Overall a nice intro, but I had to refer to online help from MSDN more often than I would love to, on having read the book pretending to be more or less coverage of the material. Still a good buy for the money. Looking forward to see a manual that covers DB testing in greater depth.

1 comments about Beginning Web Development, Silverlight, and ASP.NET AJAX: From Novice to Professional (Beginning from Novice to Professional).

1. This book is a good start for anyone who wants a quick overview of web technologies as offered by Microsoft. Roughly one-third of the book is dedicated to what would nowadays be called "traditional" web technologies based on ASP.NET. It covers a lot of areas (Web forms, ADO.NET, Web Services, deployment), but never dives very deep. The second part focuses on the Next Generation technologies for Web Development and provides an introduction to WCF, WPF, WWF, Cardspace, Ajax, APS.NET AJAX and Silverlight. Unfortunately, it only addresses Silverlight 1.0 and some interesting new developments such as LINQ and project Astoria are left out completely.
   
   I noticed quite some errors in the code examples in the book (especially in the first part), which I think should have been picked up by the reviewer.
   
   All in all, an interesting read that will certainly make the user want to visit Amazon for some more in-depth books on one or more of the many topics they've just become acquainted with.

5 comments about Organizational Patterns of Agile Software Development.

1. OK, I have to admit, this is the first book review I've ever written on Amazon and having read a lot of good books I should probably get off my a** and write more :-)

   As a former developer and now a software development manager, I have come to realise that the "soft side" or sociology of software projects (communication with clients, communication with teammates, project management, team dynamics, cultural issues, morale, division of work, remote collaboration, etc) is considerably more complicated than the programming work itself.

   Over time, you start to see patterns emerge such as "start a large project with a small experienced group and gradually phase people into a project as time goes on". This book does by far the best job of cataloguing and explaining dozens of these patterns related to (1) software project management (2) structuring, building and nurturing software project teams and (3) organization and division of development tasks to maximize the effectiveness of the team as a whole.

   Highly recommended to anyone involved with software development at both the management level and in the trenches. Have fun!




2. This book has to be The Grand Unifying Theory of Software with respect to managing the people and processes involved in software production.
   
   To anyone who has worked in the software industry, this book is clearly the product of an enormous amount of practical experience in both management of people and projects as well as the development of software.
   
   Coplien and Harrison have written a book which both the project manager and software engineer will understand and will immediately be able to apply to their respective work environments: This is because the book cunningly captures essential organisational concepts using a framework that is familiar to software engineers. Thus, the concepts will be by recognised by staff trained in business as well as those trained in software and systems.
   
   I strongly feel that the material covered in this book can achieve a common communication basis between managers and engineers, and can help business developers understand the nature of their people and organisation.
   
   If I could insist that all people in software read this book I would; but without the policing power, I can only highly recommend this book to those involved in all facets of software.



3. My initial pre-read perception of this book was that it was going to be just another perspective of agile methods. I was wrong. Coplien and Harrison have dissected development teams to identify the key criteria leading to successful efforts and high-performing teams. Beyond process, this book identifies the organizational structures required to make the processes work.
   
   From an organizational perspective, roles and responsibilities within your development teams are a primary success criteria for your agile (or any other process) adoption. This book presents how and why key roles within your teams work and why teams without these key roles don't work. The way they have presented the material provides for a quick cross-reference when you are looking for solutions to help your teams.
   
   Beyond the organization patterns themselves, I believe some of the richest material in this book is presented in the last few chapters as they present the history and importance of organizational structures, roles and responsibilities in applying process - "Process emerges from structure, and structure emerges from values". There is great value in this book beyond most software development process books.



4. I've read quite a few of Jim's works over the years, and he has never failed to impress me. This book should be required reading for any project manager!



5. As project managers, most of us who've been in the field working for a while come to realize that successful project teams are more the result of "good" ongoing social engineering of one sort or another rather than just dumping an almost randomly selected group of people together, coming up with an MS Project Plan and saying "do this" (the Death Star approach, all to common in large traditional process-driven IT shops). After this has happened to you, painfully, you begin to come to the realization that perhaps there's more to project management than the mechanistic "people are interchangeable resources" PMBOK-style approach.
   
   If it hasn't already, it begins to dawn on you that the "soft" side of project management (client relationship building, communication within the team and between teams, team dynamics and team morale, motivation, empowerment, commitment, a human-style of project management) are as important or even more important than the technical work and the technical skills required. Most of us have run across teams with prima-donna's who think they're the cat's whiskers, be they project managers or technical personnel, who have the personal graces of a warthog and who are incredibly destructive to team morale and team performance. They continue to exist, sadly, and because they often deliver, albeit at the expense of everyone who works for them or with them, they continue to survive in "Death Star" style IT shops where delivery is all important and the style of successful delivery means nothing or is short-sightedly disregarded. OK, so that's my rant.
   
   Now for the book. We've all seen successful projects and successful teams (or at least, I hope we all have). Some teams gell and perform way above the norm. What this book does is distil over 100 successfully applied organizational patterns of one sort or another from real projects in real software development groups. These patterns are broken down into logical groups (Project Management Patterns, Piecemeal Growth Patterns, Organizational Style Patterns & People and Code Patterns) which are dissected and explained, with examples provided. What the authors have done is to identify and describe key organizational patterns which are used by successful teams - not processes, but organizational structures of various types that are needed to make processes work successfully. A large amount of practical experience has gone into the content - over ten years of research experience from the authors alone.
   
   I've read a lot of books on Agile, but this is the first I've come across that sets out organizational patterns - and does it so effectively that you'll wonder why all the stuff in here never occurred to you before. As you read through the book, you'll see patterns that will make sense, the kind of "ah-ha, that's what the problem is and this is how I can dom something about it" sense. You'll find this book useful in that the contents can be taken and applied right away. It's easy to pick what is most useful for your team, what can be applied immediately and what would be nice later on, once some of the basics are in place. The content is practical in that you can easily identify what your problems are and what pattern would help fix it, why the pattern is intended to fix it, and there's good advice on how to introduce new patterns.
   
   With over 100 patterns, there are a lot, but they're set out concisely, a page or two to each pattern. There's no fluff, it's well-written, there's no appreciable bias, there's a lot of material, including some good coverage of the importance of effective organizational structures in applying process. As we all know, all the process in the world will not a great project team make. The book's structure is coherent and well-organized, the patterns described can be used individually or as groups and the authors give you some pretty good ideas as to what's immediately useful.
   
   And the pictures all the way through the book are great! A nice humorous touch that helps make the point each time. Overall, I'd recommend this book very highly as a resource to anyone managing a project / team, whether Agile or not. There's a wealth of practical advice in here that any project manager could take and use, although the orientation is towards Agile Projects. An added bonus - unlike many technical books, this one won't date quickly - organizational patterns that work don't change much over the years, unlike programming languages. From a practical point of view, I've applied some of these patterns to teams I work with and the results have been positive - I've also shared the book with co-workers and they've all found it both illuminating and useful.

5 comments about Pro JSF and Ajax: Building Rich Internet Components (Pro).

1. The authors begin "This book is not, and we would like to emphasize this, not an introductory level book..." That's for certain. Except for quick review material in the first chapter, the authors move quickly into a project that assumes a good amount of experience.
   
   The book effectively follows a pattern that you have seen before. Build a simple component, integrate it, then progressively build in functionality and complexity while dealing with usability and maintainability issues.
   
   One factor that makes this book stand out is the great number of flow diagrams. This book has the expected code printouts and screenshots but the extra emphasis on logic diagrams is exceptional. Also not seen in other JSF books are two chapters on providing Mozilla XUL and Microsoft .htc renderers. Yes, the last is a bit of a surprise!



2. If you already have a background in JavaServer Faces (JSF) and you want to start exploring the integration of that with some of the Web 2.0 technologies, Jonas Jacobi and John R. Fallows have a book that might interest you... Pro JSF and Ajax - Building Rich Internet Components.
   
   Contents:
   Part 1 - Developing Smarter with JavaServer Faces: The Foundation of JSF - Components; Defining the Date Field Component; Defining the Deck Component
   Part 2 - Designing Rich Internet Components: Using Rich Internet Technologies; Loading Resources with Weblets; Ajax Enabling the Deck Component; Ajax Enabling the Date Field Component; Providing Mozilla XUL Renderers; Providing Microsoft HTC Renderers; Switching RenderKits Dynamically
   Index
   
   To be honest, this book was beyond my current technology level. While there is a brief overview of JSF technology, you'll get the most out of the book if you already have a relatively solid grounding in it. They use two components, the Date Field and the Deck components, to show how JSF can be used to build internet application components that are able to be reused in other applications. The real value comes in Part 2, where they take those two components and start mixing them up with technologies that allow for rich internet functionality, such as Ajax and XUL. Using the examples provided, you start to see how a JSF application mixed with something like Ajax allows you to start building internet applications that behave more like desktop client apps... no round-trips to the server... no constant screen refreshes to get new content... Pretty cool stuff. I'd also recommend that you be pretty conversant with the rich internet technology already. Like with JSF, there's an assumption that you already understand the basics, so don't think that your first exposure to Ajax could be with this book. You'll be in pain if you try that route...
   
   If you've had the exposure and you're now looking for some really cool project on which to apply your JSF skills, this could easily be the book that helps you make that transition from "Hello World" to "ooooohhh..."



3. I tried reading the first chapter, got through half and realized that the overview was simply hitting the architecture big picture with no code (this is after reading the complete reference cover to cover) -- skipped to the second chapter cause I had no clue where the author was at on chapter 1. Chapter 2, trying to describe component extensions -- the code examples had a bunch of css. CSS? And no mention that css was a part or not a part of jsf. To someone without a design background this would be very confusing. Huh? Why? To take up space that's why.
   
   This is a worthless book that obfuscates. My opinion, they put this thing together to capitalize on the hype surrounding jsf and ajax with no clue as to how to actually teach how to integrate the two. Finally the most annoying thing is about half of the copy starts out "in this chapter you will ... " then some worthless unrelated code and then another section with "in this chapter you will ..." Waste of my precious time and mental space to read this book. They should take a hint from NIKE and just do it rather than talk about it. CODE... examples and more code -- I don't want to read or waste time reading "in this chapter you will"...



4. Even for an advanced developer/architect this book does not make sense. There are too many typos, wrong references to Figures and Tables, and confusing diagrams. On the top of all these things, it is poorly written. For example (Verbatim from chapter 2):
   
   Figure -1 shows the five classes you'11 create in this chapter, they are HtmlInputDateRenderer,ProInputData,UIComponentTagSupport,and ProInputDateTag, as well as two you'11 be extending Renderer and UIInput.
   
   As you can tell from the above the author is quite confusing.



5. I bought this book looking for examples on how to create custom JSF components and AJAX or extend existing components. The book is very light on this. It starts with a general overview of the JSF life cycle. Chapter 2 shows you how to create a date component and chapter 3 a deck component. Unfortunately the information is scattered and does not flow very well. Part 2 of the book has very little to do with JSF. Explains what Rich internet technologies then it give other examples of Rich Technologies which don't help you in developing JSF components It even goes into Microsoft technologies
   This book would be better with more JSF/AJAX examples and less fluff. They try to bring you from entry level knowledge to expert knowledge. If I wish to create JSF components I have been using JSF and the components available to me are limit so when I buy a book like this I do not want to start at the beginning and I am not interested in other technologies that are similar to JSF like XUL, Weblets and Microsoft HTC I have choose my technology when I come to a book like this. If you want a general high level overview this book covering technologies besides JSF this book is ok. If you want and indebt book about creating JSF components with AJAX this is not it.

No comments about Essentials of System Analysis and Design (3rd Edition).

5 comments about Unified Modeling Language User Guide, The (2nd Edition) (Addison-Wesley Object Technology Series).

1. Start reading Chapter 1 of this book for even just the first few pages, and for various topics, it will say to go to future Chapters. If you take a look at those future chapters, there will be notes on the side telling you to go back to Chapter 1 or to other chapters. You can run into infinite loops or dead ends not really picking up anything. It is possible to maybe find what you were looking for, or find that the explanation for it is just not sufficient.
   
   If I'm trying to look for a topic to remember, this book is not an easy read with the index either. If you look up some topics in the index and go to all the pages listed, it may not list all the important pages. Sometimes, when I had to look for information on something, say a "use case" for instance, then I'd look that topic up in the index. I'd go to all the different pages listed in the index and it might not be what I was looking for. Then I'd have to look at the side of the page of usually the lowest or 2nd lowest numbered page listed by the indexed topic, and go to the Chapter(s) listed. When I went to those chapter(s) I'd still have to scour the entire chapter(s) until I might find what I was looking for. An example was when I was trying to understand what one of the diagram types was, a "state diagram" I believe it was, as compared to say an "activity diagram." Sometimes I would find out that things just weren't worded well if in there at all, and I'd have to refer to another UML book.
   
   This book may have some good use, but I haven't found that yet. It's hard to read and hard to look things up, and hard to learn from if you don't already know much or anything that is for sure.



2. I picked up this book as a way to familiarize myself with the changes to UML in UML 2.0, which are extensive, as I found the OMG specification nearly impenetrable. I had liked the first edition, though I too felt Fowler's Distilled was a much better intro to give to students and engineers learning UML for the first time. This edition, though, does not meet expectations. The typos and bad references throughout are bad enough. Join that with a complete lack of real-world design examples, poor organization, and poor design. Why a chapter on State Machines and a separate chapter on State Diagrams that repeats a lot of the earlier chapter? The blue cross references make it clear that the book is spaghetti design at its worst. Check out the table of contents, you won't know where to look for your favorite diagrams; check out the index, and you won't be able to find the definition of the concept you just can't quite remember. The glossary is useful, as the UML 2.0 spec dispensed with a glossary, making it even more impenetrable. On the other hand, the authors make no attempt to call out the new UML 2.0 features, which would have made my day. What I find most unforgivable, though, is the authors' inability to present the new UML as it really is: the book is seriously misleading in many ways for learning UML 2.0. My biggest peeve is the way they treat the new and highly useful composite structure diagrams. In the list of diagrams, they don't even mention it, calling it by the name of a different diagram, the "Component Diagram", which they feel is the same thing. They then separate the discussion of composite classes and components, making it seem as though they're totally unrelated. They fail to mention quite a few of the new UML features (the X navigation adornments that make non-navigability explicit, for example, which is critical to code generation, or the fact that you can have multiple stereotypes associated with model elements. In their defense, the UML standard isn't very clear on these diagram types, but this is a practical tutorial that should take practice into account. There are constant references to the Reference Guide for more advanced features; these are mostly the UML 2.0 features that they didn't feel were important enough to include in the comprehensive tutorial. The appendix on UML notation simply ignores many UML 2.0 notations. I can't help but feel shortchanged.



3. Book is complete waste of money. Find more prevalent information online. Not really a required book. Not used at all.



4. I don't know what people who would review this book well are thinking. These authors may be good at creating the UML, but terrible at explaining it. The sentences are packed with words they haven't explained - or uncommon uses of words that really have no meaning, unless you are already a UML expert. I can't imagine a more poorly written text.



5. When I am using tools supported UML, I often search key concept with this book. Because this book is an user guide.
   I made some sequence charts, so I use some functions of UML.
   I can not understand which architecture is good or not.
   I think there are little idea about that.

5 comments about The Definitive Guide to JasperReports (Expert's Voice).

1. I miss more Java code examples in the book, also it is too much an aseptic reference of the options of JasperReports, being really not a friendly or instructive book.



2. This book does not provide enough details about the JasperReport especially about how to use it. It also be lack of examples.
   
   I strongly recommand directly using iText for PDF file generating.



3. JasperReports is a great reporting engine which suffers heavily from its utter lack of useable documentation. I bought this book, written by JasperReports' author Teodor Danciu in the hopes of finally getting adequate documentation. Boy! was I disappointed!
   
   The book is an extremely superficial overview of the product; it's really no more than a glorified README file. Chapter 5 ("Large File Support") is a perfect case in point: The classes in the virtualization API are named, but nowhere is there any explanation on how to actually use them.
   
   It's quite unfortunate that Danciu has put his name on this poor excuse for a book. Luckily, I bought the PDF version, so I wasn't responsible for any trees dying...



4. This book is not what I expected, because there is not a single example, step by step, not even a basic one, that introduce you to the practice, is just like read an API documentation and that is all you get.



5. The name suggests that this is a guide to development of reports, using an open source reporting API. That said, with APIs being the exclusive domain of the coder ... why isn't there any code? $50 down the drain.

2 comments about The Practical Guide to Defect Prevention (Best Practices).

1. This is the first review I have performed and here it goes... I work in software development and have for the last 11 years. As a Quality Assurance Professional, I think "The Practical Guide to Defect Prevention" should be on everyone's book shelf. Everyone in the industry or those contemplating a start-up in the industry should read this book to get an understanding of what quality means and how to achieve it. This is a fun book filled with real world experiences and enough technical knowledge to implement the many quality systems and is most beneficial read from end to end, but is also designed to be a reference. "The Practical Guide to Defect Prevention" does a great job of giving a strong foundation for those wanting to develop quality in their processes.
   Who can really benefit from this book?
   * The executive wanting to know what it takes to have a successful software business
   * The manager wanting to know how to improve the product
   * The product designer who wants to provide enhancements to existing features and determine what features to add
   * The developer wanting to gauge the effectiveness of the implementation
   * The tester that wants to catch all of the errors
   Sure, we could talk about all the content and implementation issues, including; Root Cause Analysis, Failure Mode and Effects Analysis (FMEA), Fault Tree Analysis (FTA) or Failure Modeling, but my favorite aspect of this book is the real world examples and pitfalls described.
   Many great related quotes are included to illustrate some aspect of the material to be presented. My favorite was in chapter 12, "Adapting Processes" where there was a quote from Mark Twain "A man who carries a cat by the tail learns something he can learn in no other way". This quote illustrates the reason you need to read this book and keep it on your bookshelf.
   Arne
   The Practical Guide to Defect Prevention (Best Practices)



2. "The Practical Guide to Defect Prevention" was written for software developers and testers, but many techniques presented can be applied to improve quality in other products as well. I'm in the midst of a career change into software development after 2 decades of working with office automation hardware, and have referred to this book during a current project, as well as passed along suggestions straight from this book to former colleagues in a much different career field. When I saw the title of this book, I was afraid I'd be reading advice that wasn't much more than common sense, or a rehash of material learned in programming or intro software testing. Wrong! Realizing how naïve I was, I picked up 2 other texts in the field of defect prevention and root cause analysis. I found this book to be more readable. The clear taxonomy, the complete explanations of various methods (with multiple examples and references) and the humor (!) held my interest enough to where I learned and understood the techniques presented, as well as broadened my understanding of what quality software development really entails.
   
   As a previous reviewer pointed out, this book is useful to everyone from the tester who wants to catch errors, through the executive wanting a successful business. And, I suppose this sounds like I'm laying it on with a trowel, but I have to say it: Although I'm a voracious reader, I keep only a few dozen books on my shelves at home; this is one of them, and I suspect that I'll continue referring to it for quite some time. Thanks to the authors Ross, Marc, Bob, Dan, David, Lori, and Josh for taking the time and putting forth such a great effort!