5 comments about JavaScript by Example (By Example).

1. I think chapter 8 misuses the term "inheritance", which will muddy the waters for someone trying to understand inheritance. It says "Each object has a prototype whose properties it inherits". Would it be better to say "You can tack new methods or properties on to an existing class (eg: String) using the prototype property"?



2. A few discrepancies between the examples, explanations, and especially the CD, eg: where I think she changed a file or variable name in one place and forgot to change it in the other, so you spend some time trying to reconstruct what she meant to say.
   Otherwise well paced, good for learning.



3. Wether or not this book is right for you, really depends on what you need from a Javascript text book. Armed with some basic knowledge of HTML, this was the perfect text to put me up to speed on the topic. There are many examples (as the title implies), giving you an exhaustive treatment of all topics. This treatment doesn't leave anything out, and though it would be nice to have the answers to the exercises, anything which stumps you can be solved by going over the examples again.
   
   There are many explanations for every example given, but it's quite easy to skip around to what you need if you know some of the material already.
   
   Excellent self-study tool.



4. Terrific book, a little (editing) problems in the book, but if you have a little experience in Javascript they can be overlooked. Actually the few errors keep you on your toes!



5. I was reading JavaScript by Example in parallel with Beginning JavaScript, 2nd Edition for a class. I found that Quigley was trying too hard to jam too much information into a small space. As someone new to JavaScript, I found her explanations difficult and her writing unclear. In comparison, Beginning JavaScript is bigger, but kinder and more comprehensible to the new reader. If weight is an issue, buy Quigley. Otherwise, you are better off with Beginning JavaScript.

1 comments about About.com Guide to Web Design: Build and Maintain a Dynamic, User-Friendly Web Site Using HTML, CSS and Javascript (About.Com Guides).

1. Part of my job as a Web designer/developer is to stay on top of current best practices, technology and software. This book covers all of that in a comprehensive but concise package.
   
   The author goes a step beyond discussing what you can and can't do with a Web site, and offers practical, understandable reasons why, and specific examples of when a particular technique or technology is appropriate.
   
   Like a well designed Web site, the book is well organized and easily readable. The links to the author's own website and others are well chosen, adding depth to the subject, and demonstrating an effective way to create a multimedia approach in which each medium plays a specific role, each complimentary to the other.
   
   This is, by far, the best book of its kind that I've seen.

5 comments about JavaScript Bible, Fifth Edition.

1. This is really a bible-level handbook of javascript. The contents are very comprehensive and look professional. The best thing is that the examples in each chapter really help understand the boring syntax and functions.



2. An overwhelming amount of information without a simple beginning. The author jumps from beginning level information to way too sophisticated so fast that it will lose any non-technical person.



3. Definitively it's the javascript bible.
   
   If you want to fine tune your AJAX apps you'd better buy this book.
   
   It's extensive object and fuction reference does not leave anything in the shadows.
   
   This book is worth every cent.



4. This "Bible" covers everything that is needed for JavaScript programming. Everything is very well written and very easy to understand with clear code examples and real world applications. The beginning tutorial is a great way to get beginners started then the more advanced topics are covered in the Book or on the CD with all of the examples listed on the CD as well.
   
   This is a book that I will continue to use.



5. Pro: really good reference work for most people
   Cons: 1) Not for someone who doesn't know either javascript basics or another scripting language. 2) Organization is good, but it isn't an encyclopedia and it isn't a start-to-finish tutorial. 3) Poor typeface decisions.
   
   This book is the greatest for several different types of people. First, anyone who knows the basics of javascript, from advanced beginner to advanced js user. Second, anyone who wants to learn javascript and already knows some programming; you can use it as a tutorial, but only if you don't need much explanation about scripts and object-oriented programming.
   
   It really is just excellent for someone who has previously learned something about one of the chapters but needs a refresher and/or more detailed/comprehensive walkthrough.
   
   Four stars instead of five for a completely unnecessary mistake. Unfortunately, the W3c ignores people who do not have eagle-sharp vision and will fill a page full of semicolons and colons, or parens and curly brackets. If you don't have a font that clearly distinguishes these, it is a major source of semantic errors and eyestrain. The font chosen to print the code in this book could not be worse. Colons and semicolons are almost impossible to distinguish (not to mention periods and commas),and curly brackets look like thin lines with no curls.
   
   C'mon guys. There are fonts of every type where periods and commas are easier to distinguish, and curly brackets have a distinct shape. USE THEM FOR PUBLISHING CODE!!

5 comments about JavaScript: The Complete Reference, Second Edition.

1. As a CIS student with some prior programming experience, I find this 948 page tome both thorough and clearly written. The double table of contents, one brief, and the other very detailed, makes it easy to find what you need. Much attention is paid to cross-browser issues. You could concievably teach yourself JavaScript with this book alone.



2. The book is pleasantly written and easy to read, but unfortunately there are some important ommissions as far as describing the JavaScript language itself.
   
   Inheritence is barely mentioned. There is no explanation at all of how to invoke the parent constructor with parameters.
   
   Exceptions are not explained at all in the first part of the book, which is the language guide. Instead they are mentioned at the very end - in the applied programming examples.
   
   There is no good explanation of the internal logic of the language - why certain things are as they are and how they fit together.
   
   Considering the recent trend of writing full blown JavaScript applications, there is a lot to be desired.
   
   The book is much better as a guide to applying simple JavaScript. It covers a wide variety of topics in sufficient detail - DHTML, XMLHTTPRequest, etc. The example scripts do not seem to be production quality, but they serve the purpose of illustrating the ideas well enough.



3. The text is a very good and complete explanation of JavaScript. It describes the best usage of JavaScript with the latest common browsers at the time of writing (early 2004). There are numerous examples which express the programming ideas in a simple fashion.
   
   If you have programmed in other languages, JavaScript should be an easy learn with this book. Programs written in it tend not to be very long, as they are associated with a single web page. While JavaScript deals nicely with the various objects in a browser, like a window or document, the programs tend to have a procedural flavour.



4. This is a fairly comprehensive book. This is not the best "beginner" book. The "beginner" info is in there - but it's mixed with so much advanced stuff that it can seem overwhelming. If you have previous experience, there's a lot of good stuff here. This is an excellent "second book."



5. The future is Javascript. Being a Microsoft technologies fanatic, I always wanted to make use of the AJAX library. My javascript needed some brusing and this was the book I went after. The complete reference, and a good companion to HTML/XHTML Complete Reference. David Flaganan's book is good too. Both deserve 5 stars.

5 comments about ppk on JavaScript, 1/e (VOICES).

1. PPK's website is probably the most authorative and up-to-date ressource on internet, but when it comes to JavaScript, one could not be less interesting. The book contains a few tips on accessibility but look no further.



2. PPK on JavaScript by Peter-Paul Koch might just be the most thorough JavaScript book I have read. Through the use of eight real-world example scripts, PPK walks us through JavaScript from the very beginning. Over the years JavaScript has had its ups and downs. This is mainly due to the flux of poorly optimized scripts that are scattered around the Internet. So how do you know what source to trust? What are some best practices for JavaScript? How can you utilize JavaScript to add enhancements to your site without breaking in the browser? How can you create scripts that will enhance the user experience and not hurt it? All of these topics and more are discussed in this book.
   
   Throughout the ten chapters and 499 pages of this book, there is very little that isn't covered on the topic. Let's take a look at the organization and flow of the book:
   
   Purpose
   This chapter paints the big picture for us. There is no jumping into scripts or coding in the first few chapters. Here we get an overview of some important aspects of JavaScript. One of the most important aspects is the coverage of the history of JavaScript. Though some might find this to be boring, I believe it to be invaluable. Understanding the history of JavaScript gives you a better idea of how it has formed into the language it is today. This is one of the most valuable parts of the book. It sets a solid foundation for everything else that is covered.
   
   Context
   Along with understanding the history, it is good to see where JavaScript fits into the big picture of web development. Here we take an in-depth look at HTML, CSS, and JavaScript. There are many distinctions to be made here as each could potentially mix with the other. It is important to keep a clean separation of your structure (HTML), presentation (CSS), and your behavior (JavaScript). At some points the line may become blurry on mixing the two, which is why each aspect is discussed in detail. These include separation of presentation and structure, separation of behavior and structure, and separation of behavior and presentation.
   
   Not every user or device has JavaScript enabled. Moving forward we look at the impact on accessibility and how it affects things such as no mouse, screen readers, and usability. These are all important pieces that must be addressed as we begin adding advanced functionality to our website.
   
   Lastly we are introduced to the eight example scripts that we will encounter: Textarea MaxLength, Usable Forms, Form Validation, Dropdown Menu, Edit Style Sheet, Sandwich Picker, XMLHTTP Speed Meter, and Site Survey.
   
   Browsers
   This chapter provides a little more context and history into the different browser families. We look not only at browsers but other devices such as mobile phones and screen readers. We look at each of these and are then shown some of the incompatibilities that they suffer. We address the problems and look to build solutions to patch the holes. Next we look at solving problems by using two different techniques: object detection and browser detection. Object detection works by checking if the methods you are using are supported before you use them. Browser detection tries to detect the current User Agent and then build from there. Browser detection has many flaws associated with it. One specifically is browser spoofing where you can send a different User Agent string to the server, lying to the application about the available technology. There are correct uses, but this should mostly be avoided.
   
   If you have been developing JavaScript for a while then you are probably used to using the alert method to help in the debugging process. Here were are introduced to debugging, figuring out some of the cryptic messages returned by the browser, and how we can deal with browser bugs.
   
   Preparation
   Planning is important for all projects. Here we are introduced to preparing our application for enhancements. This involves having the proper placements of hooks. Hooks are found by using an ID, class, custom attributes (not a widely accepted solution), and name/value pairs.
   
   Once we have our hooks in place, we have to get access to them to make our modifications. Having access is only part of the process. We also have to learn how to generate content when necessary and understanding the relationships inside of the DOM. We get a brief primer on setting up our script tag and how we can utilize multiple scripts if necessary.
   
   Our hooks are in place, and we know where we want to apply our effects. How and when should they fire? We stop to take a look at the initialization of scripts and the load event. This method has its pitfalls, which are discussed and alternate solutions are addressed. We take a look back to the example scripts for some more insight and real-world use cases.
   
   Core
   Everything we have done to this point hinges on our ability to actually program the functionality we are trying to achieve. This section walks through the basics of programming in JavaScript. We look at statements, comments, code blocks, operators, values, and case sensitivity. Next we look at the six different data types that are available to us, and how JavaScript handles conversion and concatenation. We look at ways to explicitly convert our data types when necessary. After looking at the data types we look at some of the common operators. These are inherent to every programming language, so there isn't much new in this area. We've looked at the constructs, now we move to discussing variables: proper naming, the var keyword, and variable scope. This is very important to grasp as we move forward and create our own functions to achieve our tasks. Next we look at working with numbers, strings, and booleans inside of our scripts. We have a good foundation, now we move to control structures such as if, switch, for, while, do/while, break and continue, and try/catch. The next few sections focus on defining and working with custom functions, creating and defining objects and their methods and properties, and finally dealing with arrays. The section on arrays is especially helpful as it discussed how you can loop over them and how you can add, delete, and locate specific sections inside of an array.
   
   BOM
   This section looks at the Browser Object Model and the window object. We take a look at the global window object and its impact on creating new pages and cross communication between windows. We then look at navigation within the window and the location and history. We learn how to manipulate the geometry of the window, and how to retrieve information about the current window dimensions.
   
   The chapter rounds off with discussion of some miscellaneous functions such as alert, confirm, prompt and timeouts and intervals. We take a closer look at some of the available methods for the document object. Finally, we take a look at working with cookies and utilizing/managing them within our application.
   
   Events
   This is probably one of the most important sections of this book. This section gives a thorough look at all of the available events. The chapter first starts by looking at some compatibilities and how to resolve them case by case. We take an in-depth look at all of the available events at our disposal and how they work. We look at event registration and the best way to handle it. The rest of this chapter discusses event bubbling and capturing and the browser support related to each, the event object and its properties available to us, targeting your elements, and then implementing some of our new-found knowledge in the example scripts. Sometimes grasping events and event registration can be tough, but this chapter makes it easy through illustration and the example scripts.
   
   DOM
   We have come a long way to this point. We have set our foundation, looked at the core of JavaScript, examined the browser window and its properties, and learned how to set our events in motion. Now it is time to look at the Document Object Model. The DOM holds all of the information inside of our pages. It is comprised of all elements and attributes and their relationship to one another. They are commonly referred to as nodes that build the family tree. Understanding of this structure is what gives us the power to build elements and insert them or delete them. We have full control over our internal structure.
   
   However, it is never that easy. Traversing the DOM can sometimes be painful, especially when you see some of the differences between browsers. We take a look at how to find our nodes, how we can retrieve information about those nodes, and how we can change our document tree through appending, inserting, removing, and replacing. We are also introduced to creating elements and creating text nodes, and then how we can achieve some of the above tasks.
   
   This chapter rounds off with the always heated discussion of the use of innerHTML, finding attributes and setting their values, dealing with text nodes - even empty text nodes that sometimes cause confusion, understanding and traversing the nodeLists, and dealing with forms and the Level 0 DOM. All of these pieces help us put together the big puzzle as we are using JavaScript to manipulate our pages.
   
   CSS Modification
   Earlier we discussed the aspect of keeping your presentation separate from your behavior. This chapter discusses best practices for working between the two. We learn how to get style information from our elements, and then how we can add classes dynamically. We take a brief look at the possibility of changing the entire stylesheet via JavaScript. While this is a nice introduction, I think it would require a specific project.
   
   The last parts of this chapter look at some examples of keeping the clean separation, but applying some visual enhancements. We work through some examples of toggling display of elements, animating elements, and changing the dimensions and position of elements.
   
   Data Retrieval
   This chapter is all about AJAX. We look at the XMLHttpRequest object and how to make it work cross browser through some conditional checks. Once we have sent the request, we need to know how to handle the response. We look at the different statuses and response codes that we will be dealing with and how to set callback functions to handle the response. We look at the available return formats such as XML, HTML, JSON, and CSV. The final part to this chapter looks at the impact that AJAX has on accessibility.
   
   This review alone does not do this book justice. This book thoroughly discussed each and every aspect to JavaScript, from its history to looking to its future. The example scripts helped to grasp the different concepts, but the real meat of the book was in the specific coverage of each aspect. There are many books about specific aspects of JavaScript, but this book combines them all into one resource. If you are just getting your feet wet in JavaScript, then this book is the perfect book to help take you to the next level.



3. Javascript has been around for a while but it is still going places. ppk on Javascript sorts through all the fluff to deliver rock solid information. The author is using a very clear language to express his deep experience in this field.
   
   Javascript is moving fast and the book does not cover some of the recent advances like the rise of Ajax, ActionScript, Tamarin. It is still a must read for any serious (javascript) programmer.



4. This book talks about scripting the DOM. Everything is clearly exposed : the history that make browsers like they are and not better, the tree behind an HTML document and the nodes behind tags and attributes, how to use css properties for the best, and how to manage events and their properties in all browsers, and of course the core of the javascript language.
   There is nothing about objects and all other OOP stuff, so I think this book is very well suited for beginners. But specialist will also find a lot of interesting things.
   One more advantage, the presentation and layout are really more pleasant than what is generally found in this category's books.



5. I bought this book because I was familiar with the author and his website, quirksmode. I figured this guy was a master of JavaScript and a book written from him would be a solid resource to learn from.
   
   Well, I was half-right. Early on in the book he presents a script and says that you should know what it does before reading his book. Well, I knew what it was, but it's not the truth. This book is all about technique and execution. He shows innovative and great ways to implement code, but you have to know how to write javascript first. If you're not an experienced programmer or are unfamiliar with javascript, you may want to consider this book...after you've gotten a proven beginner's manual and gone through that first. Head First Javascript or Javascript in 21 days are good examples.

No comments about Mootools Essentials: The Official Mootools Cookbook for JavaScript/Ajax Development (Firstpress).

5 comments about Beginning JavaScript with DOM Scripting and Ajax: From Novice to Professional (Beginning: from Novice to Professional).

1. I liked this book - it has many real applications and explanations. I found myself slipping in markers on lots of pages so that I could come back for information that I knew I needed or showed a better way to code something that I had already done.



2. He makes me cringe because he describes a lot of practices that are just really cheesy and annoying. People new to programming who start with this book are not going to advance the state of javascript enabled websites. Also, the examples are overly long. There's a 4 page example for each concept.



3. Just be aware of what you're getting into when you buy this book. It is *for beginners*, not for experienced developers. It spends the first 90 pages covering for- and while-loops, if-tests, and the rest of the machinery that you already know if you're an experienced programmer. It is the fate of most computer books, I'm afraid, that they either address rank beginners or professional software developers, with few addressing those in the middle.
   
   After every chapter, I had to take a second to recapitulate what I had just learned into the terminology that I'm aware of from my experience with other languages. One large section, for instance, is devoted to namespace-collision issues -- but the word "namespare" appears nowhere in the index. If you need a book that will jumpstart to "Here's how you solve the namespace-collision problem in JavaScript," this book is not for you.
   
   I had lots of specific questions, having just come to JavaScript. How do I set up a callback *chain*, for instance, on something like the window.onload event? This book is not at that level. It will be unable to answer that question for you. It spends so much time on beginners that it doesn't have enough time to help with best practices or common, cookbook-type programming problems.
   
   And yet it does seem confused about exactly who its audience is. Right after a chapter on basic flow control, Heilmann tosses off "XSLT" as though he expects his readers to know what that is. I submit that those who needed the first chapter will not need the XSLT bit, and conversely.
   
   So just be aware what you're getting into. I'm actually not blaming Heilmann, though I do blame whoever gave the book its title; it's much more about novices than professionals. If you look on the back of this book, you'll see the flow chart that Apress recommends: start with Heilmann's book, and progress into "Pro JavaScript Techniques" and "Pro CSS Techniques." "Pro Javascript" will be my next step.



4. I have been going through a lot of javascript books to find that all of them want to teach you the trivial things javascript can do. Not only are the examples trivial, they teach the reader horrible habits. This book doesn't have any "Hello World" examples. It gets into what javascript SHOULD be used for, and how to use it correctly. Other reviews have said that the examples do not work. Do not let that throw you off. I went through the ENTIRE book and every single example worked for me. There are a few towards the end that require a server or a local host like xampp, but either way they still worked. Another review also complained about the DOMhelp library that Chris creates. Chris explains EVERY method in that library before you use it. The library does not do trivial things like "getLinks" You learn how to do that the regular way with the DOM. I think that reviewer got that method mixed up with DOMhelp.getTarget which gets the correct target that a user clicked on depending on which browser the user is using. That is mostly what Chris developed the library for, browser cross compatibility so you don't have to write extensive code. Simply put, some of the other reviews were not very well thought out. If you want to learn useful javascript the right way with plenty of examples to help you learn it, then this is the book for you.



5. Beginning Javascript Development with Dom Scripting and Ajax provides a good smattering of projects and samples of what you can do these days with (yikes) javascript. If you've avoided javascript because it just wasn't worth the pain, come back to it and start with this book.
   
   It will take you through a "just right" primer of javascript. Not to cheesy and simple, not to lengthy or complicated. Then it will take you through the wonderful and wacky ways javascript can be used these days.
   It progresses through DOM scripting, browsers and windows and forms (oh my!), ajax and some third party javascript libraries - and does these by using small pojects and examples that you can use. **That's right it's real code for real projects - not just a relisting of someone elses javascript documentation.
   
   You may not read or use all of the chapters right away. But it is a great reference to dive back into when an idea strikes you and you need a reliable starting point.

5 comments about JavaScript for Dummies.

1. Not to sound trite, but this book was written by Dummies.... the examples are not true to life, there are too many mistakes and the explaination of JavaScript is too complicated and overblown.



2. I bought this book with a basic knowledge of HTML but very little knowledge of Javascript. Being a fan of other "Dummies" books, I thought this would be a great place to start learning Javascript. Do I feel ripped off! In the Introduction, the author states the book is for those with little or no knowledge of Javascript, which I don't think at all to be the case. She claims to use "real-world examples", most of which I find to be fairly abstract and very poorly explained. She also claims that all the sample codes are contained on the CD-ROM, which is a flat out lie, the applications are similar but the coding is very different from the book, which combined with the author's hard-to-follow explanations leaves the reader very confused and frustrated. On top of all that there are several typos, one of which refering to Microsoft Windows as a word processing program, and poorly written HTML, missing several tags. The author definately knows Javascript, but how good she is as an author is questionable.



3. I have several complaints about this book. Firstly, the author assumes you don't even know how to turn on a computer. Who would be bothering to learn about JavaScript if they don't even know how to power up a PC? Come on! The author should spend less time detailing the basic boot up process on the PC and how to open your text editor, and more time explaining the way JavaScript works, and how it depends on the browser that the person visiting your website is using to work correctly. Also, a lot of the examples given in this book don't work. (Unfortunately, I've found that is common with JavaScript books.) Also, the book seems to waste a lot of time going on and on about useless nonsense. I know it's a "dummies" book, but this book expects its readers to truly be morons.

   I'm only thankful I purchased the book at a discount bookstore for only $3.99.




4. I've been learning and using JavaScript for quite some time, and of all of the books I've used, this one has by far been the worst. The examples that the author uses are not very helpful, and often concepts are poorly explained. A lot of the code you will need to write will require you to creatively use the skills you've acquired to solve a problem; this book, however, likely won't equip you with the tools you need to be able to do this. If you're looking for a good place to start, I'd start with JavaScript: The Definitive Guide by David Flanagan. It does have flaws of its own, but it is a good place to start.



5. This book is good for a quick introduction to JavaScript. There's lots of general tricks and techniques, plenty of ideas, and code snippets to reuse (on the CD). However, the descriptions of HOW the code worked I found lacking. There were various details about exactly WHAT the Js interpreter was doing to parse the code. The book left me feeling that I had lots of great ideas, but that when I sat down to apply them and make something original--there'd be lots of bugs based on details that I wasn't told about. Good starter, good reference--definitely not "text-book" quality--but it was fun to play with.

5 comments about JavaScript for the World Wide Web, Fifth Edition (Visual QuickStart Guide).

1. Believe it or not, this book is an acutal textbook for a course I am taking in college. I was hoping for a book better than this for a college course.



2. The authors are not very good at explaining things, even relatively simple things such as the prompt() method or the dot syntax. It could be much clearer and they could do it with fewer words. The authors take a rambling tone that doesn't quite give you the information you need. You can't depend on the authors to give you meaningful explanations. You have to experiment and try different things.
   It's possible to learn JavaScript with this book, but it will take much more time than is necessary. In five editions, why couldn't they have improved this book? What are they doing? Other Visual Quickstart Guides are the same way. I hope the Visual Quickstart Guides go out of business and some other company takes over the market share. They've been cavalier toward their customers and don't deserve to be in business much longer.
   Other books like JavaScript: The Definitive Guide by Flanagan, and JavaScript: The Complete Reference by Powell and Schneider are better at explaining the language even though they are considered to be more advanced books.
   The same authors have published JavaScript & AJAX for the Web, which has almost the exact same content only it has a couple of AJAX chapters thrown in. Check out the review by another customer (at this point it is the only review). His critique is very similar to this one.
   On the positive side, the authors manage to get most of the information across and the content is relevant for the majority of users.
   If you choose to buy this book, use it as more of a guide and do not depend on it. Purchase other books to supplement it.



3. This is useful as a reference book or to learn JavaScript. I do not use it often, but when I need it I am very glad to have it on my shelf. Good examples.



4. This book was well packaged for delivery. I like it for the clarity with which the authors present the various lessons.
   
   I hope to derive a lot from it and to add to my skills.
   
   I am still going through it and so far it has been very exciting. Thank you for the good business. A value for the money.



5. It's downloads don't work, and the book requires that they be used.
   the examples will not run as written in the book.
   They do not conform to the w3schools standards.
   it cannot be used outside Microsoft products.
   Like Firefox.

4 comments about JavaScript Bible.

1. The content of this book is Excellent, the wait was worth it. I'm glad someone finally consolidated all the JavaScript information into a publication, which brings me to a criticism, not about the content. The print is too small. I believe it would have been better to turn this into a two book publication and make the print bigger (and blacker), the paper could also be whiter for better contrast and a heavier weight. Yes it would have been more expensive, but you wouldn't go blind trying to read it.



2. Just got started and got to Ch 3 and ran into a snag...page 22...lines 19 and 20 are duplicate as such:
   
   

   Let's Script...

   
   

   ---

   
   
   Thus, you see there is no closing tag for "

   ---

   " yet the book states it complies with DHTML that all tags will be closed. Also, the "Let's Script" appears twice if you use the book example.
   
   Additionally, the enclosed CD-ROM for "ch03.script1.htm" link is wrong as it should be "ch03.script1.html." If you are new to JavaScript, the work around is to access "My Computer," then your DVD/CD drive and "Content," then "Chap03," then "script1.html."
   
   I think the editors and proof readers assumed .htm was the norm and overlooked "script1.html."
   
   First script, first impression...not looking too good.
   
   I'll keep you posted as I advance through the book.
   
   Additionally, I tried to communicate with Wiley Publishing, Inc...but got caught in a loop as I posed a question to them and unknown to me they only allowed 80 characters, but I went over the limit and in their text block they allowed me to keep typing.



3. I have a few javascript books already, but they are out of date. I bought this book, which claims to be published in 2007, to learn to be more DOM and W3C compliant. However, from reading this book so far, I find that the material in it are as outdated as my older books. For example, the book still encourages the use of the "innerHTML" method, which is neither a W3C recommendation, nor is it encouraged anymore. Furthermore, the book shows you to convert a "number" type to a string by doing this:
   
   var num = 100;
   num = "" + num;
   
   That's just silly. What happened to the toString() method? How about doing this?
   
   var num = 100;
   num = num.toString();
   
   Also the book doesn't encourage separation of structure from functionality. The book's examples have javascript all mixed together with the markup. This is clearly not the modern, correct, and recommended way to script a web page.
   
   So far, these are the gripes I have about this book... and I'm only on chapter 6. It makes me feel like I don't want to finish this book, because I might adopt these outdated methods of scripting.
   
   I do not recommend this book.



4. books on changing technologies are always out of date by 6 months to a year (a book this size is probably closer to a year). i Google when i need the latest info, just like the rest of the planet apparently.
   
   i understand other reviewer gripes about this book, but it is still the best printed resource available. the book weighs in at a hefty 35 chapters and 5 Appendices in about 1200 pages (and yes the print is small). i found the information well organized, with a decent layout and a useable contents and index. this book tries to serve both the novice and the professional, and frankly does a pretty good job. a book this size obviously has errors, but nothing i would categorize as lethal (it's not a cookbook but has some decent template scripts to get you going). no one could write a book this size and comprehensive from scratch, this book is clearly an evolution and uses "revised" content from previous editions. i got the feeling reading this book that the authors write real code for real world apps. i thought about docking a star because it is has so much information. i seem to have got conditioned over the years to have a slight sense of dread when i have to open a large book to look something up. However, IMHO, the real value is searchable CD version of the book, hence back to 5 stars. this has 23 Bonus chapters! yes that's 23 bonus chapters which add over 500 pages. a nice touch was having references to the CD version (marked with a BC prefix) in the index of the print edition.
   
   from a purist point of view some of the recommendations are wrong, but from a pragmatic point of view no one is going to be impressed with your W3C compliant script that runs 10-20x slower than the non-compliant one (and that's not just in IE).
   
   inevitably a little dated but still the most comprehensive javascript book available.