5 comments about Pro OGRE 3D Programming (Pro).

1. It was a good start for Ogre and really fill some blanks from the tutorial. I thought it would be covering more intermediate and advanced aspects and features of Ogre.
   Ogre is such a wonderful engine and it needs a "Ogre's Bible" title.



2. While this text represents what amounts to a noble effort on behalf of the author and the Ogre community, I'm afraid that the best I can say for this book is that it's not entirely terrible. Hoping to fast-forward past the traditionally hackish explanations offered by online documentation, I had purchased this book expecting to learn about Ogre in a more carefully structured and comprehensive (not to mention, professional) manner. Unfortunately, this was simply not to be.
   
   The examples in this book... suck. They're terrible. Everything is simply copied (often incorrectly!) from the freely available Ogre samples. What's more, any explanation of this code is purely cursory, often suggesting that the reader "Check the website for more details," which are apparently too involved or lengthy for inclusion in this $35 hardcover text on Ogre. Oops.
   
   Perhaps I've been spoiled by the OpenGL programming guide. For one reason or another, I've come to expect concise examples that illustrate a single idea presented with plenty of discussion on how this idea might be used in practice and some exposition as to what features exist to allow one to best do so. Compared to this expectation, what this book manages to give you is a tiny sampling of a semi-relevant example drawn from the SDK's sample projects, partnered with the name of the classes and member functions involved in said example all laid out in a nice monospace font, and that's about the sum of it (give or take one or two sentences of description-- sometimes). For instance, while one whole page is dedicated to a laundry-list of the Camera's member functions (clearly copied wholesale from the header file with minimal corrections), maybe three or four functions for interacting with the scene graph are *shown* (not presented) in the context of-- you guessed it-- a small subset of some Ogre sample project. This and some sample code showing how to query the scene in one or two ways is basically all you get from the ~30 page chapter dedicated to the subject.
   
   Often times, the author spends pages upon pages singing praise to a particular feature of Ogre (render queues, techniques, LOD, schemes...), proceeding thereupon to omit any sort of actual explanation of how this feature is used later in the text. As you might imagine, this habit becomes quite annoying by the third or fourth time it occurs. Worse, still, is that any discussion that *is* presented by the author often culminates in a lacking, vague, and ambiguous description that ultimately fails to convey any sense of "The Big Picture." For one reason or another, the author seems convinced that a six line code snippet from the SDK is sufficient to explain just about everything there is to know about, say, Materials or SceneManager instances. And in the end, you feel *almost* as inexperienced with this library as you did when you originally set out to learn Ogre. Of course, by the time you've finished this book, you'll also have learned the valuable lesson that the website is really quite good-- but I'd bet that's not exactly the lesson you were planning to take from this book when you plunked down your money for it in the first place.
   
   One final criticism: be warned! When this book first arrived, I was quite surprised to discover just how thin it was. Before you assume that it's because this book is concise and to-the-point also note that the print is TINY. It's a real pain that the publisher decided to cut corners and use a 10 point font to cut down on page count all the while selling this text as a clunky hardcover book! This, coupled with the numerous typos, bugs, and inconsistencies make for a very unprofessional read. If this were a freely available tutorial you could find somewhere on the website, I'd give it 4 stars. But this is a pricey, hardcover book that's supposed to be professionally edited, organized, and polished; hence, it gets 2 stars.
   
   Okay, okay. This book isn't entirely bad. It's always nice when an open source project becomes big enough to warrant a book. And I'm sure that the author had fine intentions when setting out to write this text: some of the chapters do manage a decent description of their subject matter, and the author's enthusiasm for Ogre is quite evident in his writing (which can be amusing, at times). Unfortunately, however, this book is just not there yet: it is a thorough sales pitch, a high-level tutorial, and many suggestions to visit the website; expect nothing more.
   
   My suggestion? Take his advice, and save some money. Visit the website and skip this book.



3. Spending all day reading and implementing obscure APIs, you tend to develop thick skin for badly written documentation. Programmers generally don't have english degrees. You suffer through and glean the information you need to get your job done.
   
   I'll cut to the chase on this review. This book contains NO information. That's right, it tells you nothing about how to use Ogre. The author spends the first quarter of the book on downloading, installing, and calling the init function (which takes up to three arguments).
   
   Halfway through the book I started thinking "He's actually going to put and object in a scene any minute now". Nope, it never happens. After spending a hundred pages talking about how great Ogre is and the four types of objects he skips over actually using any of the objects. The book doesn't even cover the object trees. It flops back and forth between halfway done remedial 3D concepts (What is a camera? I'll tell you in chapter 7) and marketing speek (Ogre has a great plugin archtitecture you should love only I won't tell you how to use it).
   
   I'm still in awe that something this free of actual content could be published. After reading the entire book, I still had no idea how to perform basic functions in Ogre like loading a texture.
   
   This book has no audience. It doesn't really cover any basic 3D concepts so it's bad for beginners. It doesn't cover how to use the APIs so it's bad for a bootstrap reference, and it doesn't cover any core logic so it's bad for advanced developers. No one should ever buy this book.



4. This book was a well written , easily and objective. The goal of this book is to describe who to use Ogre 3D framework and you main functionality. I only would recommend this book for advanced developers .



5. The book presents all the crucial information in a very organized manner. I found the presentation to be concise and easy to read.
   
   Warning: The book does not teach you how to make a game, It explains the core api functions of OGRE and some background behind them. This should give you a good start to utilize the 3d rendering capability offered by OGRE. You need another book or a course in game design before you can really start making non-trivial games.

3 comments about Professional VSTO 2005: Visual Studio 2005 Tools for Office (Programmer to Programmer).

1. VSTO (pronounced Visto) is a most interesting product when viewed from Microsoft's overall standpoint. It is a very carefully crafted product with the primary purpose of continuing Microsoft's continued dominance of the desktop marketplace, and a part of Microsoft's thrust to move more heavily into the server marketplace.
   
   As best I can tell, it works something like this. Microsoft recognizes that servers handling up web pages, processing mail, etc. are a huge market, but that Linnux owns a big percentage of that market. Consequently Microsoft came up with the .NET strategy. .NET is a bunch of subroutines (if you will) that are written to provides all kinds of utility to programmers. You write your applications using propriatary programming languages such as C# and J# that use the .NET library and consequently have to run on Microsoft operating systems.
   
   In the Office environment, packages such as OpenOffice have gotten to be pretty good, are basically Microsoft compatible so you don't have a re-training problem, and are FREE. I don't know how much success OpenOffice has had, but it appears to be enough to attract Microsoft's attention.
   
   Enter VSTO. VSTO adds customization and productivity to Microsoft Office applications through 'links' that tie Office to the .NET framework. So to use VSTO first you must have and load the .NET framework, then you must load Visual Studio.NET - in that order -- then install Visual Studio 2005 Tools for Office.
   
   All of this is clearly explained by Mr. Bruney in this book, who then goes on to do an excellent job of explaing how to write programs using VSTO. As examples he includes some real world applications. Most of the book is on Excel applications, but Word and Outlook are included as well. Finally he concludes the book with an excellent discussion on pivot tables.
   
   Conclusion: A well written, understandable and complete book on VSTO. If you're going to be using VSTO, this is an excellent place to start.



2. I bought this book because it was available from a 3rd party seller for a very low price. For the money it was okay. It got me familiar with VSTO. However, I'm very glad I didn't pay full price because frankly the text is full of errors, typos and mistakes. E.g., in one paragraph he is talking about the Range object and when referring to an object there is a particular font and style that is used. However, the Range gets referred to 1) using the style, 2) without the style but with a leading capital letter, 3) without the style and all lower case. Consequently I had to re-read the paragraph 3 or 4 times to figure out if he meant "range" in the English definition or the object. A pain. This sort of thing is all over the book.
   
   Also I was reading it so I could automate Word and I found very little practical data in the chapters on Word.
   
   So, unless you are getting it as cheap as I did, I'd say find a better book.



3. Like so many books an help manuals written today, this book never tells you how the pieces fit together. The section on Word starts with an example which occurs on the "ThisDocument_Startup" event, which then opens another document. (Actually, most of the examples are nested in an event handler of that name.) The author doesn't tell us what would ever cause this code to execute -- is it part of a standalone application? Is it triggered when you open a particular file with Word? etc.
   
   I need to write code which operates in place of a Word macro -- i.e. there's a toolbar added to Word via a Global Template, and it has a button, and when that button is clicked, an object is instantiated which then begins to interact with the user and with Word. I've skimmed the entire section on Word, and found nothing of relevance. I'm ready to just skip out and buy another book.

5 comments about Setting Up LAMP: Getting Linux, Apache, MySQL, and PHP Working Together.

1. One of the things I liked about this book was the amount of detail it had on its subjects, and yet it is not a 1000 page novel. If you just want to have a system running a web server and you don't really care about how it works and what is going on, then this is definitely not the book for you. However, if you really want to learn how these components work together and exactly what is going on, then I do recommend this book. After taking a Linux course, I picked this up and still learned quite a bit from the introduction to Linux chapter. Everything is very clearly written and easy to understand. The only thing I didn't like was that many of the pages are devoted to listing configuration files, but you can easily just skip over these if they don't apply to you.



2. This book is listed as a beginner to intermediate book, but I would rate it as intermediate at the very least. The author has a fetish for unnecessarily elaborate terminology that overcomplicates straightforward operational activities (to exemplify my point). Otherwise, it is a good overview of the four technologies and how they work together to provide a seamless web presence.



3. I am very unsatisfied with this book. It only gives instructions on how to setup a lamp using one distro only. And it was geared only to well experienced users. The book was incomprehensible to me.



4. This book was probably great a couple of years ago. It has great step-by-step instructions, and it walks you through things in a very detailed manner.
   
   However, since the versions of all software (and the OS) used in the book have been updated at least a few times since 2004, I ran into several issues. Maybe 10% of all the links are accurate (which you need to install the .rpm files in the way the book tells you to), and when you do find the updated versions of everything, some of the commands the book gives you produce errors. Since the instructions probably worked correctly in 2004, there is no information on what those errors mean or how to fix them.
   
   In short, I'm setting this book aside to find something more recent, and reloading the system I was using to test this with. If you do not have prior experience and a good understanding of how all of these programs work and how to troubleshoot their errors, I would recommend finding a more up-to-date book.



5. At the moment, don't buy this book. The reason: what is otherwise an excellent book cannot be followed, because the essential steps it takes you through require resources that are not available - ie. the web resources no longer exist. Time is money, and after spending another long day yesterday, running into one dead end after another, one failed work around after another, this book has cost me lots, and I've not achieved anywhere near Setting Up Lamp. The authors/publisher could correct this easily enough, by providing the info on their website. If these issues are corrected, the book is likely to rate differently. Until that time, invest elsewhere.

2 comments about NUnit Pocket Reference (Pocket Reference (O'Reilly)).

1. Unit testing is an ideal that many programming projects should aspire to. Like yours, eh? In Java, that gave rise to JUnit. Well, as .NET has grown, so did the need for unit testing in it. From the open source movement, we now have NUnit. Still not as well known as JUnit. Which may add to the need for this book.
   
   A quick pocket reference that is competently done. Lets you easily thumb through and get what you need. The attraction of NUnit is that it can automate a framework for unit testing. There is really not much to NUnit, as attested by the book. But, then again, there is not much need for anything more complicated.



2. This pocket reference is very useful for getting NUnit running and to get you started on making test harnesses of your own. Great buy.

No comments about Excel as Your Database.

5 comments about Blog Design Solutions.

1. I would give this book 5 stars but not untill I can fix my 1045 error I recieved when I try to connect phpmyadmin to mysql, I'll give it one. The book looks really good but for me the instructions for phpmyadmin don't work and I tried every thing possible. I will be returning this book soon unless I find the solution. Update after 4 days of trying I found a way to connect phpmyadmin to mysql. So I'll give this book 4 Stars! The versions of phpMyAdmin and MySQL as in the book are out of date but the latest versions will still work.



2. Bought this book mainly for Simon Collision's chapter on ExpressionEngine. Really helpful; love the way he imparts info. EE's worth paying for, definitely, but its creators also offer a completely robust free version. Free as in free, not a trial. Careful, though - you'll want to upgrade to the licensed version after working with EE for a bit. ;)



3. I've been a software designer / programmer for 30 some years, working at various levels from programmer to project director so I don't feel like I'm easily intimidated by "tech talk". I also recognize this to be an example of poor quality documentation and technical / tutorial writing and editing. This book seems to be written for "the insiders' community" i.e. experienced CMS, PHP, mySQL website developers.
   
   I found the intro material shallow and repetitive, just filling up pages in some places. I bought the book particularly for the WordPress chapter - looking for documentation to take me from installation, through design options, explanation of concepts, and examples of a variety of blog types, how to design and implement them using WordPress tools and rsources. I found instead small examples of snatches of code to be inserted, who knows where and with little explanation of purpose or design / integration considerations (like no variables or links defined). There is also no adequate bibliography or background list of tutorials to create a conceptual environment or even to facilitate looking up terms.
   
   If you had done this stuff before, these are probably useful tidbits and the name dropping and personal asides might be cute but between the insider jokes and jabs and lack of structured documentation, I found this material next to useless.
   
   Needless to say, I returned this book - the first time I've availed myself of Amazon's return policy in about 100 purchases.



4. Chapter seven.."write your own blog engine" alone is worth the price of the book. If you are a beginning to intermediate php "developer" and want to learn how to build a useful expandable CMS and blog, then buy this book. No goofy writer promoting their buddies add on products here. You get the information and clear guidance you need to build your own system.
   I do stress that you should know some php to tackle chapter seven. If you do you can will see the flexiblity in the system and be able to take the blog engine presented in the book to new levels. Even if you don't know php, but can follow instructions you will build a blog that is as good as any packaged deal available.
   If you are fuzzy on page layouts and css, this book will help clear it up.
   If you are interested in writing your own software instead of reengineering someone elses then get this book. If you want to make one of the popular packaged blog engined uniquely your own, then buy this book. It teaches how to do just that.



5. I would like to start by saying this is a book about setting up and running your own blog. If you don't want to get into the design aspects and coding a blog, then you will not like this book as it is not for the people who simply want a setup like blogger.
   
   One thing this book does well is give you an idea of 4 major packages for blog development and one chapter for writing your own engine.
   
   The 4 main packages are:
   
   Movable type seems capable but for some reason it just didn't interest me. It's a little more work then using blogger but I don't know. Wordpress seems to offer much more.
   
   ExpressionEngine is a rather robust package. To me it's for the people who really want to tinker with the guts of a setup. Might be overkill for many bloggers.
   
   Wordpress is a rather nice package which I am told is heavily used. It appears easy to use and setup. To me it seems more people that want to tinker a little bit but want an easy way to do things. I am considering this for my company.
   
   Textpattern seems to be geared towards running a blogging site. It's appears very versatile and seems to organize things really well. I am considering this when I become more advanced at blogging.
   
   The last chapter shows you how to write your own engine. This would be a fun little programming exercise that I will do at a later date!
   
   Overall this is a great little book that will answer questions on design. It will definitely answer your question of if you want to host your own versus using something like blogger.

5 comments about Automated Software Testing: Introduction, Management, and Performance.

1. As an engineer involved with software QA for a number of years, I found the book to be so generalized as to be essentially worthless. The authors devote page after page to explain methods and procedures with diagrams that depict the intuitively obvious. Their ATLM (Automated Test Life-Cycle Methodology) is as complicated as diagramming the Earth's water cycle. I don't need to spend Forty odd dollars and peruse 600 pages to learn that I might be able to use some nonspecific automated testing tool somewhere along the software development process.



2. I recently joined a firm that simply wanted to purchase an automated test tool within two weeks; "it made little difference which tool". Using this book, they became convinced we should install at least three tools, on evaluation. Good thing we did: we found that only one could deal with "customized" Java applets used in their applications.

   Little did our test team know beforehand that new automated tools require evaluation: what technologies are your applications using? what levels of test planning and scripting skills will be required for each tool? what other tools may be necessary sooner or later? and, does your test tool vendor of choice market such complementary tools? And much, much more.

   "Automated Software Testing" guides readers through each step in the planning, selection, and implementation process to assure that automated software testing will be developed in a systematic manner.

   See the table of contents. You will find that for less than the cost of a testers time for two hours, your business will be investing in knowledge that will save perhaps hundreds of thousands of dollars over the life of your applications.




3. This is one of THE books if you plan on implementing automated testing in your software shop. Covers everything from Lifecycle to tool evaluations to best practices. This one that is definitely on my "bookshelf on the go" that follows me to all projects. I especially appreciated the Appendix with real world stuff and references to tool manufacturers. Great work!



4. Unfortunately this book (like nearly all other books on software testing) does not teach you how to test software. Instead it only gives you information needed to manage software testing. And, like many other books of management, it is highly repetitive and redundant. For somebody needing compressed information this is the wrong book. I think it would be no big deal to reduce the number of pages to 50% and still deliver the same message. The exmamples given in the text read like from a psychology book, not like from a technical book. Despite my critique I have to admit that the annexes in the book can be highly valuable. Personally I liked best the review of the big number of test tools.



5. This book as far as I am concerned is best automation software testing book written ever.

2 comments about Effective Prototyping for Software Makers (Interactive Technologies).

1. As a visual interface designer (and a reviewer of this book while in its manuscript stages), and as someone who has worked for fifteen years in software interface design, I recommend this book. The authors are experienced designers themselves, and this book is strong on both theory and practical advice. It can be read through in page order or used as a reference for just-in-time help. The text provides detailed advice about how to select and use appropriate tools for building various kinds of prototypes, how to plan for the full range of prototyping activities, and guidelines for basic visual interface design. As far as I know, there is no other text available covering this range of topics.
   
   The authors also talk about important process issues, and talk about how prototyping is used to learn not only about product features but also about users and markets. They argue that prototypes are a risk-reducing activity, and this business case for prototyping may the best way to promote adoption of more and better prototyping practices.
   
   The text is well organized and does a good job of identifying appropriate techniques for early, mid-term, and late development phases. This won't substitute for actual professional experience, but it will undoubtedly save many readers from choosing the wrong method at the wrong time. The book is a virtual template for best practices in software prototyping.
   
   Another important aspect of the book is the author's attention to the value of prototyping in supporting collaborative work and building a shared sense of purpose and strategy among teams. It's another argument that ought to appeal to management.
   
   This is an ideal text for software engineers and designers who have not done much prototyping as well as students in engineering, design, and human factors. I recommend it to my own clients who are still developing their capability in this area. A basic familiarity with the aspects of prototyping presented in this volume should really be considered a part of the fundamental knowledge base of anyone in the software development field.



2. Two stars to the publisher. This book is verbose, as most American books are. It is good of course to clarify concepts and to repeat them in different chapters, but my impression after having read a part of it is that it is definitely too much, as the same concept is repeated three or four times withing two-three pages.
   I am sure that this 560 pages book could have been published on 200-250 pages. Not only because the text could have been shorter. Some images are used two or three times in the book even unnecessarily, and some of them provide a little value add to the comprehension. Moreover, a large amount of space is being used for visual maps that represent steps in the process, as if designers were children who need large coloured titles repeated throughout the whole book extensively as signposts.
   Quite a good reference to all different prototyping techniques, but as a professional IA and UI designer, I am sure that this stuff is obsolete compared to what one can find on the web.

3 comments about Software Quality Assurance: From Theory to Implementation.

1. Although written as a college text (the publisher also has instructor manual, syllabus and discussion guidelines, and test material), this book sufficiently reflects real world SQA to be used by working practitioners. My review focus is on the latter use.

   Chapters that will be of interest to real world SQA include Chapter 3. Software Quality Factors (excellent foundation for a metrics initiative), Chapter 5. Contract Review (checklists for proposal and contract review are excellent), Chapters 7 (Integrating Quality Activities in the Project Life Cycle - especially the model for SQA defect removal effectiveness and cost) and 8 (Reviews, which includes supporting templates), and Chapter 11. Assuring The Quality of Software Maintenance, which is an often overlooked aspect of SQA.

   Note that this book has been written to support ISO 9001 and contains chapters that are specifically slanted towards that approach. Included are chapters on document and configuration control, auditing, and attaining ISO 9001 certification. The author also provides solid information on ISO/IEC Quality Assurance standards, IEEE/ANSI Standards, and MIL-STD-498, as well as on common assessment approaches (CMM and SPICE).

   As a textbook the coverage of every facet of SQA from why and what, to testing, metrics and its role in organizations and projects are thoroughly covered. The fact that the material is up-to-date and truly reflects the real world makes this one of the better texts for college level courses because it does prepare students for roles as practitioners.




2. Galin explains why software is usually far harder to test than hardware. The latter usually only has a few modes of operation, thousands at most. While the combinatorics of any nontrivial software package can easily produce millions of modes. Also, hardware defects (like parts missing) are often easy to detect by visual inspection. While software is often inherently opaque. It might have a corrupted or missing module that might not be found until the customer tries to use it. This is exacerbated by bugs being found essentially mostly in development and testing. And not in manufacturing. This latter step is trivial is software, but is the key step in hardware.
   
   His book then goes over the main types of Software Quality Assurance models. These might already be familiar to you. The Waterfall model, which forms the basis of most SQA standards. But for small software projects, you might be able to use the Prototyping model, which can be faster. If you have a complex project, then maybe try the Spiral model. Here the spiral is a useful metaphor that indicates a hopeful convergence of the project at the centre of a Spiral chart.
   
   Then there is the Object Oriented model. Which takes its inspiration from the rise of OO languages like C++ and Java. As you build up a library of classes, then the more useful this model becomes, at the project level.
   
   Each of the above models is concisely explained. The entire book has this flavour. With a continual emphasis on metrics, as these are crucial to permitting an objective assessment of your project. In some ways, without taking sides as to which model you might adopt, the book seems to suggest that doing the metrics may be at least as important. So that you get some tangible idea of how your project is progressing.
   
   It is also nice to see that he gives no mention of Extreme Programming. This is a dead end that was briefly popular amongst some developers, until its disadvantages became apparent.
   
   The book is structured somewhat like a textbook, with questions at the end of each chapter. Certainly useful in focusing your attention. But its usage as an actual text in a university course seems unlikely. Not due to any failing in the book. But simply that computer science departments rarely teach this topic in any detail. Mostly left to industry.



3. Up front, this is one of the most dry and boring techical texts that I have ever read. Reading the book is as interesting as reading your insurance policy. I had (as part of a class that I was taking) to read the book cover to cover and can definitely say that this was a hard experience. The book uses very few examples and for the most part, they are useless. They do not carry a point nor explain any of the material they cover. The material is arranges in a confused way and does not flow from one chapter to another, nor does the structure of the chapters make any sense.
   The reason I give this book 2 stars is that is does cover the various areas that SQA is concerned with. Going over the table of contents would give you enough information to look somewhere else for a better text.

5 comments about AdvancED DOM Scripting: Dynamic Web Design Techniques (Advanced).

1. This is truly a next generation book for building software on the web. There is nothing like it anywhere else. If you want to add the functionality, scalability, accessibility and the inevitable "bling of web 2.0", then you NEED to buy this book.
   
   Jeff's writing style and tone in this book are perfect. He makes complicated topics simple and intuitive and presents real-world examples you can use today.
   
   Only Caution: Don't buy this if you're a beginner (it's an AdvancED book for a reason). You'll want a good understanding of CSS, Javascript and HTML to get the most out of this book. All professional web software engineers will want this book close by 24/7.



2. The author clearly knows his stuff but I find the book hard to understand. Is it the author or my level of javascript experience? Hard to say. I will say this - you probably want to know javascript very well before getting this book. For those taking learning steps in javascript like myself, this book is far from the next step from Jeremy Keith's books.



3. UPDATE (3-17-08)
   
   I bought this book again because the material is definitely good. I'm really bummed Friends Of Ed let it go to press with all these errors though. I mean, come on--I'm finding errors all over the place! That is a great disservice to Sambells. But I've decided the material is worth wading through the many, many copy editing oversights. I'm crossing my fingers I don't get stuck troubleshooting typos in the code that choke my browser. That could easily waste hours of my time.
   -=-=-
   
   I was pretty excited after I dropped the $50 or so to by this book because the contents are right down my alley. Unfortunately, I could hardly make it out of Chapter 1 for all the typos and editorial oversights. Here are a few as an example:
   
   PG 34 -- "myVarialbe" instead of "myVariable"
   PG 35 -- "when you retrieving" instead of "when you are retrieving"
   PG 36 -- references a function called "initAchors()" that isn't used in the example code for that example. initAnchors() appears in the next example on the next page.
   PG 37 -- number of iterations in loop changes from 3 to 5 from 1st example to 2nd example for no apparent reason - this is confusing and distracts from the point being made.
   PG 37 -- Figure 1-7 shows three objects in diagram instead of the 5 needed (one for each loop)
   
   This is all in just 3 pages!
   
   This is the part of the book I started reading first so I assume the rest of the book is going to be as poorly edited/ proofread. This surprises me as I own over 5 or 6 titles from the Friend Of Ed series and I don't recall ever seeing so much as a typo in any of them.
   
   Overall, I think the book shows promise. But I can't tolerate errors like this in a programming book. They are difficult enough to read already without having to figure out what the message was "supposed" to be.
   
   I'm returning this book to the store. When it reaches a later edition I may give it another go. It needs some serious "debuggin" first though.



4. This is the greatest Modern JavaScript, DOM Scripting, and AJAX book I've ever seen. Having done AJAX since 1999 before the buzzword ever became popular, I can say that a book this exhaustive has never been written before now. It covers everything from the JavaScript's often misunderstood variable scope to the deep interaction with the DOM and everything in between.
   
   This book is an intermediate to advanced book that requires that you have some understanding of our every day web technologies. If you are a web developer, then you are required to know XHTML and JavaScript anyway. This isn't just some surace level "how-to" book. This covers the deep internals of AJAX and will make you an expert.
   
   Feel free to ignore anyone who claims this book contains spelling errors or other things that in no way change the overall structure of the book and that any thinking person can get around. No ant will ever make a sky scraper fall; it's irrelevant. This isn't an English book or a book for novices. It's a practically graduate-level JavaScript/DOM/AJAX book that requires you to be a thinking person to begin with.



5. If you already know a lot about scripting it is probably a brilliant book but do not attempt to read it as a newbie.
   I am not new to scripting but I found most of it too advanced - The parts I could follow had great solutions and suggestions though.