DOM Scripting: Web Design with JavaScript and the Document Object Model

• #16 in Best Javascript Books

65 Reviews

Sort by: Most Helpful ▲ Date Rating

This book is directed toward scripters at the beginning and intermediate level. This is also a very good book for the veteran scripter who wants to re-tool as DOM-based techniques take hold.

I think Jeremy Keith takes the best road when he launches directly into DOM methods and objects, only mentioning the older ways for completeness. Most often, JavaScript books do the opposite -- mentioning DOM scripting only as an advanced art. But why learn the older ways when you must unlearn them later?

The author focuses on teaching correct methods and approaches, often taking the long way around to make it easier to see the larger picture. This requires a lot of forethought and organization on the part of an author and here the material excels. I don't think anyone will trip up following this guide through the Web script jungle.

The author also avoids the unbearable humor and cutesy language encountered so often in tech books. Thank you Mr. Keith! This is good, clear writing to go with good, clean scripting.

Quibbles: I think the author should have been more concerned with compatibility issues, esp. with IE6, the decrepit but still dominant browser. For instance, on pp 200-01, he recommends using the setAttribute() method to set a class but does not mention that IE improperly demands "className" as a parameter. His snippet would fail in IE. The chapter on CSS scripting was good but barely scratched the surface, not mentioning a bunch of cool scriptable objects.

Overall, this book is a worthy tool that should be welcomed by the target audience.

There's been a lull in the past couple years with JavaScript books. Even though there are many sites that use DHTML and DOM scripting, there never was any books that really explain how to do these very useful and cool effects. Plenty of websites to download and copy code, but nothing that really explains how to do it. UNTIL NOW!!!

The moment I start reading the first chapter, I knew I would finally learn what DOM scripting really meant. I've read through many basic JavaScript books from different publishers but all of them just briefly described how the DOM worked in one brief chapter. The whole DOM Scripting book talks about it.

The first 2 chapters are a brief refresher course of the JavaScript basics, and then the 3rd chapter starts in with the DOM. After a thorough explanation of what it is and how it can be used, the next chapters go through various projects in reviewing how it can be used in real life web design.

There are eight chapters that explain and show you how DOM scripting can be used. The final chapter talks about the future of scripting and gives examples of AJAX--a great bonus!

I highly recommend this book to anybody who wants to take their JavaScript code to the next level. It's also a great book to help would-be AJAX programmers as well. Since you have to have a very good understanding of DOM to create AJAX applications.

When a Javascript/DOM book:
1) ..starts by introducing Javascript and it's syntax instead of jumping into DOM immediately.
2) ..Explains every single bit of code in a simple language.
3) ..uses simple and easy-to-follow code.
4) ..Starts a chapter with a very simple program and build on it as you read.
5) ..lets you put up your first useful/practical Javascript script in a few hours.
6) ..encourages you to 'understand' the code instead of 'memorizing' it
7) ..is written by Jeremy Keith

..Then you know it's worth every single cent you spend on it. I have nothing to say here except that if you're someone who knows nothing about Javascript/DOM and is willing to learn it, then you really shouldn't miss this book. But If you're an intermediate or advanced Javascript/DOM coder, then buying this book is not a good idea. It was solely made for begginers.

The intent of the author is to show how JavaScript, with the DOM Api, can indeed be used in an intelligent way, debunking the myth (somehow justified by the horrific javascript code laying around) that "scripting languages" are somehow inherently inferior to compiled ones. Incidentally, this effort is similar to what Damian Conway has recently done, in a larger scale, for Perl ("Perl Best Practices").

The book is at its best when it describes how to methodically partition the design of a web page in 3 areas: the content-markup (xhtml), the presentation (css), the behavior (JavaScript, DOM). Jeremy Keith achieves this not by abruptly inflicting the reader with massive dosis of W3C standards, but rather "by evolution", taking one example (an "image gallery") coded in the traditional way, and continuously improving and refining it. Incidentally, the web pages that emerge are of a stunning beauty.

The book has its weak moments; I mention only two of them, one on the theory, the other on programming:

1) an apparent inconsistency on the properties of childNode[] array. After having repeatedly stated that this array contains ALL the children of an element node ("including the attribute nodes", see p. 67), it suddenly states (p. 70, p. 154, etc) that the text node of a paragraph node is the first and ONLY node of childNodes[]. Some tests (using elements that had attributes) confirmed that this last statement was correct. So, apparently, the childNodes[] array of an element does NOT report its attribute nodes, contradicting the first assertion.

2) the function "showPicture()", the central routine of the example that runs across all the book. All is fine, until Jeremy suddenly decides to change (ch 6, p. 106) its return to "true" when the function fails, and "false" when it succeeds. This is done in order to easily propagate the indication to the browser whether to follow the link or not, but... let me put it this way: would you write routine "start_shuttle()" to return "true" when the requested action fails, just because it makes life "easier" (?) for some intermediate caller routine? let's hope not (for the astronauts' sake).
Furthermore, as show Picture() had multiple returns inside, each one of them had to be tweaked in the "tricky" way; contrast this potential maintenance nightmare with instead returning the right value and simply switching it in the caller. The code (a la D. Conway "self-documented" way) could be:
"var followLink = ! showPicture(); return followLink".
A comment can be added to remove any residual doubt for people maintaing the code in future: "if showPic() succeds, tell browser not to follow the link, and viceversa".

I want to underline that, while the code is sometimes of poor quality, the design of the software of the examples is excellent, way above anything else that one sees for JavaScript. Separation of "behavior" from "content" was not an empty slogan; by chapter 7, the goal is reached. Not only all the JavaScript code is out of the html page, but even the elements that were not strictly "content" are out (they are now dynamically created).
And the page works without a glitch ("gracefully degraded", as Jeremy says) even if JavaScript is disabled (or if it is a robot reading it, etc). Fantastic.

I therefore reccomend this book to anyone interested to a methodic introduction to client-side programming with JavaScript and the DOM. A good Css book (like the one from Lie & Bos, to reach exactly the same objective on the presentation side) can be a great companion, on this trip to greater things (Ayax & co).

I ended up returning this book.

Basically I was looking for a book that gave me enough background and detail on both JavaScript and the Document Object Model to help me build mechanisms.

This book provides a good conceptual overview of how one can use JavaScript in combination with DOM to do things.

But it is a relatively small book, it has few examples, and no in-depth info on either JavaScript or DOM. And it has little useful information on the difference between how the various browsers deal with DOM.

I created a JavaScript/DOM mechanism that would change the fields presented in a webform depending on radio button selections at the top of the form. The mechanism worked fine in FireFox, Safari, and Opera but would not function in IE6. I eventually found a workaround but the book was no help.

If all you want is an overview of what you can do with JavaScript and DOM then this book is OK. If you really want help getting something built then you will need to get a different book.

I've been working with and writing JavaScript for several years now. Additionally, I've been following the practices that this book espouses for the last year or so. I didn't expect to learn an incredible amount from this book, but I was wrong. While I already understood most of the concepts, Mr. Keith explained them with unrivaled clarity.

This book is nothing short of a revolution in educating developers about the true potential of DOM Scripting (JavaScript). Mr. Keith does an excellent job setting the stage, explaining the landscape, and showing how and why the old ways are no longer acceptable.

At the same time, he clearly illustrates that client-side scripting can be both advanced and accessible at the same time by deftly explaining the concepts of progressive enhancement and graceful degradation in parallel with concise and easy to understand code samples.

This book is an absolute must for anyone that wishes to take JavaScript seriously. A definitive reference guide may make you aware of the tools you have at your disposal, but this book will show you how to really use those tools and achieve the best possible results.

Whether you're just get started with scripting or have been using it for years, this is a book that should be in your library.

Over Thanksgiving break, I was able to set aside some time to get reading done that I have been putting off for awhile. I have just finished reading the tome of knowledge entitled DOM Scripting, and have to say that I was very pleased with this book. It is written by Jeremy Keith, who is one of, if not the leading expert in JavaScript and the Document Object Model. The forward to the book is done by Dave Shea, curator of the popular site CSS Zen Garden.

In the case of highly technical subjects, documentation is usually quite widespread. Most programming textbooks will tell you what you need to know, in some way or another. The thing I like about this one is the way in which Jeremy presents the information. He uses everyday, practical examples of JavaScript, such as making an interactive photo gallery.

I also like how he does not tout JavaScript as the end-all solution for web design. In several cases, he will show how to do something with JavaScript, and then gives a more simple example of how it would work with CSS. He makes mention of how simple image roll-overs need not be handled by JS anymore, because of the CSS a:hover handles it better and with less code.

This book relates to the reader in a manner that assumes a shared basic knowledge of XHTML and CSS. It is full of examples of selecting nodes via the getElementByTag method, not unlike the way CSS interacts with the DOM. For instance, with CSS every H1 in a document can be given a certain style.

By using JavaScript, you can affect these by changing color, margin or padding directly. Jeremy gives examples of how instead of re-defining these types of things with JS, you can simple assign a different class name to them, and control the styles via CSS, the way you normally would.

He also shows how to impliment current-page indicators in a navigation system, but conceeds that things like this are better handled with server-side scripting. It is refereshing to see an author who is humble about his area of expertise, presenting it as a piece of a larger system, and showing areas in which it might not be the best fit for the task at hand.

I could go on and on, but I think that if I give away too much, that might be giving you the book for free. So, take my advice: If you are wondering what all this DOM / AJAX buzz is, then go get this book. It will give you a solid handle on the underlying principles of the DOM, and show you how to use a combination of JavaScript and CSS to best manipulate behavior within your webpages.

Is this book for the advanced? No. More importantly, perhaps, it really is a book about the DOM, not about Javascript in general.

I'd already been pretty comfortable with Javascript and DOM manipulation by the time I finally picked up this book. Of course, I was comfortable with these topics primarily because I'd spent time dissecting Jeremy Keith's own Adactio Elsewhere, a brilliant and dynamic javascript-powered Web 2.0 application.

But there's no coverage at all here of objects, closures, or any of the hairier stuff that makes scripts like sIFR and Prototype tick.

So while I was disappointed to not see these more complicated topics, those that are presented are presented clearly and always with best-practices highlighted. Keith demonstrates the advantages of doing things the "right way", rather than just whacking us all over the head with some guilt-trip about accessibility.

If you've never dipped your hand into the increasingly less scary cauldron that is modern javascript, this book might be just the thing you need for that first step. It's only a small step farther to GMap mashups and greasemonkey scripts!

The book presents an excellent overview of DOM scripting for those who are unfamiliar with the topic. If you have read other books that cover the subject, though, you will only find a few additional useful peices of information not found elsewhere (e.g., writing code that degrades gracefully is *excellent* in this book).

I did have some problems with the book though. As at least one other reader mentioned, the book is *extremely* repetitive; to the point where I was utterly frustrated with an otherwise well written book. Also, this book is most definitely for beginners. As I mentioned, if you have some DOM experience you won't find this book as useful as someone without any such experience.

Overall, I feel the few useful nuggets I took away were useful but probably not worth the full price of the book. A different but excellent choice might be "DHTML Utopia - Modern Web Design Using Javascript and DOM" by Stuart Langridge. It covers the DOM as well as other very useful javascript technologies.

The analogies are great (they make things very clear) and I find myself truly grasping the concepts that Jeremy put forth in his book. As a beginner, in JavaScript and DOM, this is the first JavaScript book that makes sense!

This book makes every other JavaScript book outdated. It's concepts are clear and very well illustrated with the accompanied examples. I could easily just use the real world examples in the book, but I am motivated to create my own.

This is a great book to read start to finish, but it also has several chapters that are great reads by themselves. This is definitely a book that won't spend much time on the shelf - It has not left my desk since I got it!

DOM Scripting by Jeremy Keith gives you a very smooth introduction to JavaScript and the DOM. The books is more directed at those who are just beginning JavaScript or have used it in the past but would like more knowledge.

The book itself flows well from chapter to chapter. The beginning chapters give you a foundation to work with during the rest of the book. Jeremy teaches basic constructs of JavaScript programming and how/where they can be used. If you are already a programmer (not necessarily JavaScript), this chapter will be a quick one. It is very informational, yet straight to the point. Once he gets the basics and best practice techniques out of the way - he dives into the DOM and gives several useful examples. This is where it gets good.

Before moving further, I should mention that his best practices are applied all throughout this book - and that includes creating useful and unobtrusive JavaScript. So, with each chapter - he shows the process and then brings it around full circle to an unobtrusive model. For instance, with the image gallery example, he shows that without JavaScript, this process would be useless - and we don't need extra markup on the pages that won't be used. He shows you, step by step (with great code highlighting and screenshots), how to build the image gallery on the fly. This way, if a user HAS JavaScript they can get the better experience. For those without, it degrades gracefully and doesn't add unnecessary code to the markup. This is just one example - but is used on all of his building blocks throughout the book.

There were many times in the book I would question what was being done (from an unobtrusive standards perspective). Each of those questions was immediately answered in the paragraphs or chapters to come. Jeremy does a great job to present the big picture, along with explaining why things were done certain ways. I read this book in two days, simply because it was hard to put down. The last chapters (aside from the reference), were the icing on the cake. This is where he puts all of the pieces together for a fictional website, JayScript and the Domsters. This chapter takes all of the pieces taught throughout the book and puts them in a practical environment. Go ahead, play with the fictional site. It has nice little touches, that, even when JavaScript is disabled has a nice user experience.

Overall, I would highly recommend this book if you are looking to get your hands dirty with JavaScript and DOM Scripting. The book was an easy read, packed with useful information. Just as with CSS Mastery, each chapter would build on the last - all the way until the end where it was all put together as a whole. Also, I am currently reading "DHTML Utopia", and this book was a great primer to JavaScript techniques. Thanks, Jeremy, for a great, concise, book on a topic that can sometimes scare people away.

This book is great because it totally ignores all the other Javascript programming books that came before it. What I mean is that this book focuses on using the DOM and Javascript to accomplish tasks rather than perpetuating the Netscape Navigator 4/Internet Explorer 5 Javascript development practices. (Of course, this is what it should do, considering the title of the book.)

Another reviewer referred to the repetition in the content. Personally I find this useful as it reinforces the earlier material. (A teacher once told me that she had to repeat things about eight times before the information really sank into her student's heads.)

The only two critical comments I have are:
1. I would have liked to see more information on using/validating forms.
2. The Javascript based image gallery application seems to be a bit of a stretch for me. (Personally I think this kind of thing is better served by a server-based solution.) A better example might have been an examination of a registration process for a software package's beta program.

Other than that, the book is very good. It shows the preferred "web standards" way of using Javascript and the DOM. It will challenge people new to scripting, but in a good way. Recommended .

It describes Javascript as used in web design and not as a separate language. Most Javascript books are like other language guides, you learn the language but have no idea what to do with it. This book is about manipulating the elements (& nodes) of a web page. It's easy to read and understand. After this you can go learn more about Javascript if you need to.

I enjoyed this book. It was a very easy read and it introduced me to the subject. That said, the book should have been about 1/4 of the size it is. It is the most repetitive thing I have ever read; sometimes frustratingly so.

It should also be noted that this book is definitely for beginners.

This book is an excellent example of what computer books should be. The writing is concise and understandable. The book is structured as a series of chapters starting with the basics like Javascript syntax and history, then going on to more complex topics on utilizing the DOM. Each chapter states at the beginning what will be covered and has a brief summary at the end. The author does a great job of describing what the DOM is and isn't. The examples are clear and well explained. Then, to top it off, there is a DOM reference at the end of the book so I can quickly find and implement commands.

This book is the standard to which all other computer books should be held. Buy it. Even if you aren't interested in the topic. This guy deserves your money.

This was my first introduction to the DOM. The book explains concepts very well and builds a nice foundation to work off. I did find the book a bit tedious in some parts, but this is mostly due to the fact that I am not an advanced JS developer yet.

Don't expect to use this as a reference book. Jeremy Keith is quick to point this out in one of the first paragraphs. It is more about driving home these concepts: graceful degradation, progressive enhancement, Web standards, and separation of structure, presentation, and behavior through easily understandable examples.

I would highly recommend this book if you looking to lay down a firm foundation before jumping into the DOM. For a topic that has been scarcely covered thus far, Jeremy Keith does a good job getting us out of the gate.

As a experienced javascript user who got her start in the old-school javascript of IE and netscape V3 I knew the landscape had changed since the transition to ECMA script, real CSS support, and better DOM implementations across browsers.

Sometimes when you know an old method it's harder to develop the "good habits" that come with a more evolved version of the language and few resources really help with making that transition and discarding old bad habits and approaches.

DOM Scripting does just that. This approachable text is accessable for the person dabbling in javascript as well as those like me who occassionaly get into involved javascript work and developed skills and habits based on outmoded development model. It covers the concepts clearly and simply without being boring.

If you know some Javascript and want to do some nice DOM scripting this book is a great bootstrap. Another useful tool is Danny Goodman's Javascript Bible book.

As you can see from most of the other reviews, this book is excellent. You need this book if you fit any of these categories:
1) you struggle with javascript
2) you insert style or script into your web pages
3) you struggle with when to use getElementById and nodeType
4) you are having difficulty with pages rendering differently in different browsers (IE, Firefox, Netscape, Apple, Opera, etc).

This book teaches you how to write a single script without having to worry about which version / brand of browser AND STILL BE ABLE TO USE HIGH LEVEL CODE.

Mr. Keith teaches you all of the basics of Javascript in one chapter. Yup, he's that good! This chapter is the gold standard on how to teach a language.

Finally, the author shows you how to separate content from style from behavior while maintaining progressive enhancement and backward-compatibility through graceful degradation. If you have trouble with understanding that, it is a good indication that you need this book (grin).

I liked this book so much I went out and bought additional copies for my colleagues because:
a) I didn't want to share my copy, and
b) I didn't want to have to explain to them the advantages of the demonstrated techniques.

I sincerely hope that this author writes more books because this is such a great book.

I've been itching to properly learn Javascript for a while and had been doing so with the Javascript Bible. That is one heavy book, although a bit out-dated now. I finally came across this book and boy am I glad I did. I've learnt more concepts about javascripting practices than any other book or resources I've referred to.
This book, in my opinion, is definitely for the non-scripter/programmer. So if you're 100% new to javascript, this may not be the best choice for your first book. However, if you've touched javascript for a while or have done some sort of programming or even actionscript in Flash, this will be quite an easy read.
It's totally opened my eyes to creating sites that are no longer tagged with "Oh, it's one of those javascript-only sites again that try to be oh-so-fancy but break in other browsers".
If you want to take on the power of javascript but also be a caring, friendly web designer, this is definitely a book you should check out.

This book just makes me soooo glad that I can do the same things with Flash. The more I read, the more I felt like I must have had a stroke. Just when you think you're on the edge of grasping a block of code, Mr. Keith extends the code a few more pages for testing/checking purposes, because it needs fine-tuning, etc. The material is definitely for people who think like programmers - not designers - extremely difficult to follow. I hate javascript even more now after struggling through this book. I have no idea why anyone would rather write brain-twisting code for a simple animation than create the same thing in Flash with minimal code required!

If you're lucky enough not to be tainted by the bad habits prevalent in today's web design, development and related programming, this is THE book you should read cover-to-cover before you write your first line of code.

For the (unlucky) rest of us, we can only hope that we'll slowly move toward what this book describes - a clean approach separating content (HTML) from design (CSS) and behavior (JavaScript).

This book is a breath of fresh air in that it avoids all the old cliches of "cool" (aka cringe-making) JavaScript effects, such as tickertape effects in the browser status bar. This is JavaScript that can be put to effective use, such as replacing images without the need either to preload them or to reload the whole page. Another example is generating new content on the fly. Jeremy Keith does this by building a list of abbreviations used on a web page, a technique that would be equally valuable in automatically generating a table of contents for a long document.

This book teaches a thoughtful approach to JavaScript that degrades gracefully in older browsers, or when the user has JavaScript disabled. In the chapter on best practices, the message is driven home that technology should add to the functionality and attractiveness of a site, an approach the author calls "progressive enhancement." Exclusive technology, even something as simple as JavaScript, should never be a prerequisite for gaining access to a site's content.

Most JavaScript books leave the Document Object Model (DOM) tantalizingly to the end in the "advanced" section, whereas this one deals with nothing else. In spite of this, DOM Scripting is aimed at the beginner to intermediate user, and is made incredibly easy to understand. The purpose of each line of code is explained, and functions are built up in easily digestible blocks. Readers already familiar with DOM techniques may find some of the descriptions repetitive, but newcomers will be grateful for the way their knowledge is consolidated by seeing core techniques used in different circumstances. The clear, matter-of-fact style makes it a pleasure to read, and the final case study brings everything together in a logical and attractive site.

In general the DOM is grossly inconsistent across different browsers and versions. To create scripts that will be able to stand up against these inconsistencies requires an in-depth coverage of every conceivable node of the DOM tree. The author did an exceedingly poor job of describing the DOM and provided little to no information on how to compensate for the extensive browser incompatibilities. The only good thing about this book is that it makes for a great door stopper.

This is one of the best computer books I have ever bought. The author teaches an invaluable method of separating content, presentation and behavior in web documents. The key benefits are graceful degradation and ease of maintenance. He ends the book with a new method called AJAX, that's used to make web pages more interactive. His teaching style is first class for people who might not like to program. He presents a problem, offers increasingly better solutions and at the end of each chapter he gives a short review. Easy reading.

(6/3/06) This book is excellent for people who have been coding basic javascript for years, and want to get up to date with modern standards. For me it was a theoretical book rather than a step by step tutorial (I read it on the treadmill, not in front of my computer). There are other books that might go into more detail or show you neat tricks. But, unlike the Quickstart guide, this one shows you valid, standards compliant, accessible methods of coding. This book is repetitive, which I think is a good thing: it reviews what you've learned, so you can pick it up much later and continue where you left off, and you're not always flipping back because a point was explained 3 chapters ago.

Modern web standards encourage seperating HTML, CSS and Javascript. Now that there is less need to browser sniff, you can use the DOM to completely remove all event handlers from the HTML page and really seperate out the Javascript. This book shows you how, and makes a point as to "why".

This is a programming book that you can actually read. I highly recommend this book for web developers who have been stunted from adding dynamic features to their websites because of browser compatibility issues, fears of 508 non-compliance, WAP, etc. If and want to take that small step (though it may seem like a leap) into modern javascript programming for the web, this is a great book.

Added Note: (5/27/08) I wrote the original review exactly 2 years ago. Since then, browser support of javascript has come a long way. So, would like to reiterate, yes, this was a great book. Now it's only a great book for people who have been doing webmaster work for more than 5 years (old standards) and want to learn how to migrate to current standards. Great intro book for that. Useless for individuals who have been doing web development for less than 3 years, since they likely started my coding with current standards.

...And Jeremy says so himself. However to the casual looker, a programmer who already has a healthy grasp on JavaScript is still very likely to pick up this book. In that case I rated it down from 5 stars to 4.
It is in fact an excellent book, but I would keep in mind that this highly geared toward those wanting to get their feet wet with JavaScript for the first time.

Brilliant code examples and incredibly lucid, level-headed and technically sound explanations. The author dogedly sticks to modern coding conventions and standards, which is enlightening and refreshing. Amazingly, this is one of only a very few books on this extremely important subject (I own all the others) and it is far and away the best. I've been looking for a book on DOM scripting like this for over 3 years now - thank you Jermey Keith for writing it!

I have tried in the past to learn JavaScript, and never saw a point other than to annoy visitors. Jeremy Keith has given me a reason to truely learn this language, and has helped me to understand DOM.

This book makes sense in a clear, and consice way that most tech books don't. His examples are great, and his writing style is very readable. Definitely worth the money!

This is a great book. I learned JavaScript during a time when the differences between Netscape and IE was enough to drive you away from adding any JavaScript to your page for DHTML. This book is probably best for someone already knowleadable in JavaScript and just needs to learn how to traverse the Document Object Tree to do some cool things with today's browsers. There is not sufficient material on actually learning to program using JavaScript...get another book for that. The examples are very clear and the explanations well done. I highly recommend the book.

One of the reviewers (a 1 star) complained about the lack of material on cross-platform compatibility...well the author discusses in the first Chapter "Browser Wars" how the war is over and how the book covers the most standard features that should apply to all browsers today.

JavaScript is like a scalpel--in the wrong hands, it can lead to disaster; in the hands of a skilled surgeon, it is a powerful tool. In Jeremy Keith's DOM Scripting, the guiding principle throughout is to turn you into that surgeon. The book opens by putting JavaScript into historical perspective, then follows that with the basics of the JavaScript language and the Document Object Model (DOM). From those basics, Keith layers and weaves best practices such as standards support, progressive enhancement, graceful degradation, and accessibility, all while slowly building components that reach a final crescendo in a complete website example. (Here's a hint: if your web pages have any in-line JavaScript code or handlers such as , you're doing things wrong.) If you're looking for in-depth Ajax material here, look elsewhere. This book is all about doing JavaScript correctly--so you won't cut yourself later.

Having a bit of knowledge of javascript, but not knowing exactly how to integrate DHTML without breaking the site -- this book offers a simplistic approach to convey the techniques used and recommended by accessibility professionals and the W3C.

The only drawback after having started to work with DOM Scripting on the job is that I need more complex examples.

This book provides a couple of good example of using DOM scripting but doesn't give enough information to teach DOM CSS or Javascript. You will need additional books.

Do you know what JavaScript is? If not, turn around right now and get yourself a good book. I recommend "Professional JavaScript for Web Developers" by Nicholas Zakas. As a matter of fact, I would recommend buying that WITH this book.

Keith brings the reality of DOM scripting from the utopian future into the present. What is required: know your craft. That includes good XHTML, CSS, and basic JavaScript skills.

Keith's examples don't represent every conceivable possible use, but if you can grasp the concepts, you can apply Keith's excellent techniques to any situation.

This is also a fantastic pre-Ajax book, so if you see yourself going the Ajax way, you really need to get your head around DOM scripting, first.

Keith's book is at the top of my personal 'most recommended' list.

I consider this book an excellent primer and one of the most accurate compilations for approaching DOM and JS. My intention for purchasing the book was for deep knowledge and that's where I was let down. It does just a bit more than scratch the surface on the topic and is most accurate. Excellent book for beginners and students wanting to understand the correct way to approach DOM and JS. I would not recommend for advanced readers looking to really exercise their ability on the topics.

Provides a good clear, conceptual overview and reference. The philosophy/objectives of DOM are emphasisized by he author. Light on examples as the author indicates it will be.

Probably best for the beginning to intermediate developer who wants to improve their efficiency of DOM scripting. Other online and written references I tried were less complete and harder to use.

I would recommend this title. It is a little dated but still very helpful.

This book is excellent to help create a foundation for DOM Scripting with Javascript. The practice of unobtrusive Javascript and graceful degradation is a must. If you do not know these two terms, then this book is for you. Otherwise, this book makes a good reference, but as a developer something a little deeper may be a better choice.

This is a really well-written book. It figuratively takes you by the hand and walks you through DOM scripting. Highly recommended if you're looking for a good introduction to the DOM.

Must have it excellent book. I also recomend CSS Mastery. Great books for library.

I've been looking awhile now for a book or a resource that can teach me what is good and the best practices of web design... and I found it in this book!. Great author, although with some errors (but is is corrected in the books website). Nice job !

I recently purchased this book to get a better grasp of using Javascript "correctly". Jeremy does an incredible job of pointing out the horrid past of Javascript and opening a path to the best practices to create unobtrusive and gracefully degrading scripts that compliment, rather than control your web pages.

His examples are well thought out, revealing techniques slowly, and returning to improve them step by step. The end result is what I would call "the perfect script", and I now am left with the task of going back and fixing all my years of mistakes!

One thing to point out. This book is not a reference manual for javascript syntax. It is exactly what the title says and I am very pleased with this book!

This book gots it all together well. I love the way the author writes and the way he presents a concept. Its so easy to follow and understand. This book isn't fit for a total beginner..you're going to need at least some experience with Javascript, CSS, and HTML to be able to implement DOM in your javascript.

I've never written a review before but after reading 10 chapters of this book, I purposely had to come on here to write this review. you really should check out some of the stuff Mr. Keith demonstrates in here. This is one of the best programming books I've read. The stuff he teaches sticks to you..they are real life programming techniques that can be used to spice up your website.

Seriously, if you want to get deep into javascript, you ought to get this book. Very easy to read with very useful techniques being taught. A+ for this author. Next time I buy programming books, I will look for this author, Jeremy Keith.

DOM Scripting by Jeremy Keith turned out to be just what I was looking for. It isn't AJAX. It's JavaScript, from a solid standards based model, that promotes well formed XHTML and CSS. It's good scripting build on top of good code, which is a good thing.

If the book simply promoted "best practices" it would be worthwhile. But this is a very good teaching text, too. The last feature is so rare that I bow to Mr. Keith. So often programming texts are written by and for alpha geeks and are opaque to mere mortals. I can actually understand this book the first time through.

DOM Scripting is written, not to programmers but to designers, albeit designers who are competent hand coders, but designers, none the less. The examples make sense. The projects are ones I actually will use. And terms are described in plain English, with no assumptions of some core, pre-existing knowledge. What makes this book even friendlier is that fact that it isn't a doorstop. At less than 400 pages, including appendices, it's not so intimidating that it will never get read.

If you read and work this book, you will have a solid foundation in client side, interactive web design. If you need to do AJAX, you will have a good handle on how to work its basic tools in your web pages.

If you already know JavaScript and simply want to get current on the DOM, you should find this a quick read and not a reference.

I was thinking that this was going to be another one of those books that you wish you hadn't bought until too late. But no. The authors *does* start with some very basics, but systematically brings you to a point of technical sophistication. Ultimately a valueable resource that's changed my approach to Javascript in a significant way! Think of it as "Javascript: the 'Missing Manual'". ("Advanced DOM Scripting" by a different author in this series doesn't pack half the punch of this one though. Save your money!) Bravo!

This is a superb book for people who already know a whole lot about javascript and programing, definitely NOT for beginners! Before I bought this book I had worked my way through some popular titles like: "Teach Yourself Javascript in 24 hours", and then :"The Javascript Anthology, 101 tips tricks.."(600 pages only this volume!!) and I definitely needed all the bit of knowledge I had learned from them to keep up with the pace the author takes on in discussing advanced topics, in-depth! You do not only need to know the basic syntacs and the building blocks of the language like variables and loops etc,but you already MUST have an in-depth knowledge of such more advanced issues as regular expressions, types of objects, literal expressions, all the event registration modells in their complexity, bubbling-capturing included.. Should I continue listing? These do not seem to be for a complete beginner..
All in all, the above mentioned "Javascript Antology 101 .." IS a book for the false beginner- or rather for, the so-called "advanced beginner",but you need heavy armor and weaponry if you want to succeed with Advanced Dom scripting!

Dom Scripting was well written, with the beginner in mind. However, don't let the term beginner turn you off. The book gives fundamental guidelines for scripting with DOM and provides sound reasons for them. The style guidelines and their reasoning are enough of a reason to by the book.

The book proceeds from an introduction of JavaScript, to a photo gallery that is designed to work with or without JavaScript, and finally to a complete website.

This book is easily the best introductory coding book I've used. Not only does it take you from elementary javascript to some really practical applications of javascript for your websites, it also gives you a strong methodology for tackling problems you want to solve with javascript. It really touches on some good basic fundamentals of coding in general. Also, unlike some of the people pumping out web design books these days, Jeremy Keith writes clearly and explains things very logically. I hope he writes another soon!

For me this book was very helpful to understand the DOM. Everything is explained very well!! The examples are very clear to understand. I recommend this book to everybody how would like to learn Javascript and the DOM.

This was a great book which really helped me get a good foundation on clean web page design. Easy to read and great examples.

This book is perfect for front end developers with little to no JavaScript or DOM experience. Jeremy Keith is one of the top proponents for unobtrusive, semantic, and gracefully degrading JavaScript in the world. A must buy for anyone who ever needs to use or learn JavaScript and the Document Object Model.

One can't rely on a book to be good enough to explain things the way they should be explained. Many people give up trying to learn something because they blame themselves for not getting it. The key, I've learned, is to keep on looking until you find the resource that will. I've learned this lesson by going through a many books on JavaScript to finally end up with one that hits the nail directly on the head. That book is Jeremy Keith's DOM Scripting.

I recommend starting with this book and then following it up with Christian Heilmann's beginning JavaScript book.

Great book, no available in France. Basic Dom description but clever and useful. Jeremy Keith is a very good "teatcher". Grâce à ce livre tout devient plus facile et clair. Vraiment dommage qu'il n'existe pas de developpeurs en france qui écrivent des livres aussi bien. La collection friendsof est vraiment incontournable. Bravo et bonne suite à cette collection. FiendsOf is a very top book's edition.

I've had time lately to do a lot more reading and Jeremy Keith's DOM Scripting book is another one that belongs on your shelf if you're trying to learn any amount of JavaScript. I've hated and avoided JavaScript for years, mostly because I started my career during the browser wars and quickly grew tired of having to write different code for different browsers. Thankfully, those days are now mostly over and this book has made me love JavaScript again.

The Document Object Model (DOM) is a standard for conceptualizing and representing the contents of an HTML or XML type document. Mr. Keith's book teaches how to use JavaScript to manipulate the DOM so that you can dynamically add or remove content from a page, change the way things look, or move things around. Similar to how CSS allows you to control the presentation of your content, DOM scripting allows you to control behaviors and events.

There are lots of great JavaScript frameworks available like jQuery, Script.aculo.us, or Dojo which allow you to easily enhance your websites. In order to fully take advantage of them though, you need to have a fundamental understanding of how things like the DOM and JavaScript event handling work. That's where this book really excels. It's written primarily for web standards developers fluent in XHTML/CSS who're looking to branch into more client-side scripting.

This book is full of useful lessons and real world examples on how to make JavaScript and the DOM work in your applications. It also places a heavy focus on fundamentals and best practices such as graceful degradation which will help you make sure that your sites still function well even without the fancy JavaScript enhancements. JavaScript has long been thought to make things inaccessible but it doesn't have to be. This book stresses how to use these technologies in an efficient, unobtrusive way.

What I liked most about this book was the voice in which it was written. I've read dozens of boring hard-to-follow tech manuals over the years but this book felt more like a friend standing over your shoulder and walking you through the process. That does somewhat limit the amount of information the book can cover and it definitely doesn't go very far into advanced techniques. If you've been doing standards development and basic JavaScript for a while though, and you really want to get started on increasing your scripting skills, this book makes an excellent primer. For me it turned my impression of JavaScript from an overly-complex annoyance to an easy-to-use yet incredibly powerful tool for improving my websites.

[...]

With a friendly and humorous style of writing, this book is liable to revolutionize the way your are writing your code, bringing you to an entirely new level of programming for the web. Although not very thick - the author doesn't miss a beat. No eccentricity of the various JavaScript functions is looked over, and when you are facing a problem - just go back to the section in the book that discusses whatever function is giving you a hard time - and you are most likely to find the reason why. Also recommended is "Css Mastery" by Andy Budd.

I really enjoyed this book. Granted, I'm a big more experienced with JavaScript than the market that this book targets, but I was looking for a sort of re-introduction to straight JavaScripting - that is, without a library like Prototype or jQuery, and this book delivers. The examples are clear and easy to follow, and the author does numerous, very practical things - all in all, a great book and an enjoyable read.

David Berube
Berube Consulting

I started reading this book with little to no Javascript experience. A little less than a year later, I'm able to take the concepts from this book and really fly. This book will definitely help you learn the foundations of the DOM (Document Object Model) and how to manipulate it to do some pretty incredible stuff. Jeremy shows you the importance of separating out your CSS, Javascript and HTML and how to make it all work seamlessly. Sure, you can do all the same stuff using Prototype, jQuery, MooTools, etc. but it's important to learn the basics first before you start using those. For those of you who know nothing about Javascript, this is the book for you. You'll really have the upper hand in making some really powerful web applications.

Learning how to AJAX your web pages may leave you floating if you don't understand the DOM well enough. This book is excellent at introducing you to what the DOM is and how to use it. Most of the other comments and the book description are great so you don't need me to write that over again. I am a professional web programmer and this book helped me move from another person who liked to do everything server side to doing even more inside the browser.

I'm not a full time programmer (was one earlier), and usually play a role in product management. So my objective was to get a grasp of the technology itself and the various components of DOM/JS. This book does that job very well. From a programmers perspective it's probably an intro level book. I have to say that the book is very well organized. I'm about to start on - Bullet Proof Ajax - by the same author.

I recommend this book to anyone who wants to learn about DOM scripting and how it fits into web development.

Very easy to follow, good explanation of the DOM. The author did a good job of using examples and building on them as new concepts were introduced. Also did a good job of encouraging little snippets of reuseable code. Although he did a pretty reasonable intro upfront to Javascript in general, it would help if a reader had some programming background (especially in object-oriented concepts). Recommended.

I was like many of you, I saw some code here or there on the internet, I browsed through W3C documents and online tutorials. This book just puts it all together in a way I thought was perfect. I gives great examples and thoroughly explains each method with out going overboard on detail. It's to the point and I would recommend this to any web developer.

Loved it, with I could find more publications written this well.

I recommend this book for people who care to write high quality javascript code. Using this book I learned new techniques for manipulating (X)HTML documents in a very powerful way.

First off, this book is not targeted to me specifically. It's evident that it is written for non-programmers who want to start building web pages with more interactivity. I, on the other hand, have a lot of experience programming with many different languages including JavaScript. The one thing I always had trouble understanding is the DOM.

Understanding the DOM is separate than knowing how to program. I believe that is the central point you should understand about this book. The book will not teach you Javascript (although it does provide some great examples). It will teach you how to think about the DOM because without this understanding, you're just blindly copying-and-pasting javascript code onto pages.

Jeremy Keith takes you step-by-step through real-world examples and in each example he shows you the conventional way to do them. Then he shows you a better way, and proceeds to explain why.

The book is a very quick read; I read it in one night. I did get to skip over some of the introductory chapters which talked a little about syntax and the differences between IFs, WHILEs, and FORs. However, I wish I had this book when it first came out almost two years ago. That's a lot of time to write plenty of bad Javascript - and I've done plenty.

Very easy to read and learn book about DOM and JavaScript. Most exaples can be REALLY used in your own projects. It is writen very good, in not boring matter. Number 1 for siure.

Every web designer/developer picks up JavaScript at some stage, often learning by using scripts and snippets from the web. However, nothing is faster or more efficient than using your well-learnt knowledge to get the task done. JavaScript, contrary to popular thought, is a very powerful language and if used correctly (i.e. coupled with the DOM) can achieve fast and effective interfaces.

Jeremy Keith really knows his stuff and has put together an easy to understand, yet comprehensive guide to utilising the DOM through JavaScript. I found, through reading this book, that I now KNOW a lot of what I use on a daily basis, which has helped me to make much better decisions about using code and how to get the job done with less code and in a timely-fashion.

If you haven't bought this book; Shame on you! If you have, then you should be buying this for your work-mates!

This book it to JavaScript as CSS Mastery is to CSS. While not a book on JavaScript mastery in the slightest, it's really really good, and will teach you 98% of everything you need to know, relevant to JavaScript and the DOM. Just like efficient CSS design that separates the presentation layer from the design layer, it'll teach you how to separate (JavaScript) behavior from design, and how to ensure backwards compatibility through "graceful" degradation. That means your sites still work if the person disables or doesn't have JavaScript support.

Thank you Jeremy Keith. This book was worth every dollar I spent on it. I feel completely ready to start on Ajax in Action (a book I had previously set aside because of lack of knowledge about JavaScript and the DOM.)