I agree with most reviews for DHTML Utopia; the book is middle level, leaving beginners in the dust but pros wanting more. It is, however, well written and contains very good code and coding standards. If you are not completely new to JavaScript and DOM scripting, but would like to learn more and make sure your code is up to today's standards, then this book is for you. If you are very familiar with web scripting and/or have been writing your own unobtrusive client side code then go with a more detailed book.

I agree with most reviews for DHTML Utopia; the book is middle level, leaving beginners in the dust but pros wanting more. It is, however, well written and contains very good code and coding standards. If you are not completely new to JavaScript and DOM scripting, but would like to learn more and make sure your code is up to today's standards, then this book is for you. If you are very familiar with web scripting and/or have been writing your own unobtrusive client side code then go with a more detailed book.

This book has a lot of great stuff but you have to have the patience to sit down and read it line by line. Can't scan through the book and hope to learn something. Even need to type in the script and try it yourself. Some of the most important ideas the author just covered in two sentences. It does teach a lot of useful stuff but it is absolutely not a beginner's book. Save me from my job interview.

(this was originally published on www.last-child.com)

This is a difficult book to read for non-javascript programmers. If you are more comfortable with HTML and CSS, I'd recommend reading Jeremy Keith's DOM Scripting first. Keith explains the theories behind this book.

That said, I did learn enough from DHTML Utopia to not look like a complete idiot during my job interview with Yahoo. This book is filled with project examples for you to follow along with. I will say that I tried several of the examples and had mixed results. I visited the book's web site to get updated code.

If you've already worked with Javascript, this is a great book to have on the shelf. If you are a rookie, start with Jeremy Keith and follow up with DHTML Utopia.

As a developer with no prior JavaScript experience, I've been very disappointed with this book. In the Introduction section, the author says "Some experience with JavaScript might also be useful, but it is by no means critical" (Page VIII) which isn't true.

Throughout the book, the author will keep assuming (implicitly) that you already have a good programming background (he uses a more complex logic in his code),and will leave many things unexplained or explained too late. This alone will easily guarantee frustration. NO BOOK EVER frustrated me that much.

Another issue is that the book uses some very complicated examples with complex logic. Unlike other decent coding books, instead of starting with simple functional examples and developing them\it as you read a chapter, the author uses one big example and "tries" to explain it part by part throughout the chapter. This might force you to "memorize" the script(s) since they contain too much code to understand (which is not the point). To make sure if the examples of the book suit you or not, download the free sample chapters from Sitepoint.com and check the "table highlight" example at the end of chapter 3. That's how most of the examples will be presented. (with more code of course)

Now don't get me wrong, the topics covered in this book are great, but it seems that the only people who will really appreciate it are those who already have a good background in JavaScript (logic,functions,methods...etc) NOT beginners like myself. So if you're trying to learn JavaScript\DOM, then go find a better book (such as "DOM scripting").

As a developer with no prior JavaScript experience, I've been very disappointed with this book. In the Introduction section, the author says "Some experience with JavaScript might also be useful, but it is by no means critical" (Page VIII) which isn't true.

Throughout the book, the author will keep assuming (implicitly) that you already have a good programming background (he uses a more complex logic in his code),and will leave many things unexplained or explained too late. This alone will easily guarantee frustration. NO BOOK EVER frustrated me that much.

Another issue is that the book uses some very complicated examples with complex logic. Unlike other decent coding books, instead of starting with simple functional examples and developing them\it as you read a chapter, the author uses one big example and "tries" to explain it part by part throughout the chapter. This might force you to "memorize" the script(s) since they contain too much code to understand (which is not the point). To make sure if the examples of the book suit you or not, download the free sample chapters from Sitepoint.com and check the "table highlight" example at the end of chapter 3. That's how most of the examples will be presented. (with more code of course)

Now don't get me wrong, the topics covered in this book are great, but it seems that the only people who will really appreciate it are those who already have a good background in JavaScript (logic,functions,methods...etc) NOT beginners like myself. So if you're trying to learn JavaScript\DOM, then go find a better book (such as "DOM scripting").

This is without doubt the worst book on DHTML/Javascript that I've ever read. The author tries to be cute, funny and authorative but ends up just plain painful. The examples are over-long and artificial, and would be difficult to incorporate into a real world application. The author peppers the book with snazzy shots like "It's the modern way!" but rarely explains the benefits of the methodology he's pushing, and glosses over any shortcomings.
For instance, in discussing regular expressions he provides a simple expression for a telephone number, then points out that it's seriously flawed. But it's "suitable for our discussion" so onward we press, and a correct solution is never provided. Bad luck if you were after such a beast. (Footnotes abound - often just URLs to now broken links - so you have to wonder why he couldn't have provided the solution at the bottom of the page.) The part on Ajax is a joke - he just plugs in an out-of-date version of the Sarissa library and never scratches below the surface.
Beware.

This is without doubt the worst book on DHTML/Javascript that I've ever read. The author tries to be cute, funny and authorative but ends up just plain painful. The examples are over-long and artificial, and would be difficult to incorporate into a real world application. The author peppers the book with snazzy shots like "It's the modern way!" but rarely explains the benefits of the methodology he's pushing, and glosses over any shortcomings.
For instance, in discussing regular expressions he provides a simple expression for a telephone number, then points out that it's seriously flawed. But it's "suitable for our discussion" so onward we press, and a correct solution is never provided. Bad luck if you were after such a beast. (Footnotes abound - often just URLs to now broken links - so you have to wonder why he couldn't have provided the solution at the bottom of the page.) The part on Ajax is a joke - he just plugs in an out-of-date version of the Sarissa library and never scratches below the surface.
Beware.

I got this book looking to find more coverage on how dhtml/ajax works. I got a book very light on details and focused on very broad how-to/cut-and-paste type scripts. So, partly, it was my own fault for not reading the back closely enough - it was never meant for deep coverage.

Even given the premise of the book, it is very light on content. As another reader points out, wide margins and big fonts take up a lot of space. Also, he inists on repeatedly putting the same functions in every example - rather than pointing readers to a website with full source as almost every other book does.

There were a few interesting ideas in the book, which was it's saving grace. But the organization of the book was the give away, he claims that you can read chapters in any order. His coverage is so high level that there's no buildup of knowledge, even for his target audience of novice programmers. How can that be, you ask? The explanatations of how things work were very broad and offered no insight to how to use things outside the scope. A book like this, should have been a cheap tiny book, maybe that came with a cd, for ready to use scripts.

If you're looking for something one step above copy and paste, to garner some basic understanding of what you're doing, this book may be for you. For anyone with javascript experience looking for something more meaningful this book is definitely not for you. For anyone beginning in javascript looking to actually be able to program on your own, this book is not for you. Zakas' wrox book was much more in depth even for topics that his book doesn't profess to cover like CSS.

This is a short book with wide spacing, large fonts, and many trivial examples. To people who have read "JavaScript: The Definitive Guide" or other references, this book offers nothing.

Reading the book is often uncomfortable. The author is not funny, cute, expert, authoritative, or anything else that he tries to be.

With the "bad old days" of browser sniffing behind us, this book explains how DHTML should be done today. This book is a good reality check for those web developers who still tend to do things the old way out of habit. It shows practical real-life examples of how to separate data from presentation and behavior. It emphasizes unobtrusive javascript. I liked the examples that compared "this is how you USED to do things" with "this is how we do it now that we know better."

You can go deeper with other books as this book just scratches the surface of modern DHTML.

Stuart Langridge's survey of modern scripting techniques is very worthwhile for those who've dabbled in object-oriented JavaScript programming but who have clung to approaches learned years ago. The focus is on the DOM supported in the current generation of browsers -- or rather, on the various DOMs; Langridge is very good at explaining the differences among them and providing work-arounds. His scripts work well where they can work, and fail gracefully where they can't.

I was hoping the book would cover AJAX to a greater degree than it does; this material is essentially confined to chapter 8 and isn't well-integrated with the core material. However, AJAX is still relatively new, and I imagine that if there's a second edition this material will be expanded.

Books of this type and length all suffer from a similar drawback, which is that only a single line of attack can be explored and developed in depth. Thus the same general approach is followed throughout, and the same libraries used for almost all the examples. So the book will not serve as a comprehensive survey; it's best for those who have already developed alternate approaches.

As others have mentioned, there is a somewhat large jump in difficulty between chapters 4 and 5, but it's not as large as in some books of this type. (Even in other O'Reilly books, one finds three or four chapters of baby steps, and then an inadequately-explained quantum leap to a new conceptual level. Langridge does handle this better than most.)

In sum, I recommend this book to the experienced JavaScript programmer who wants to come to terms with modern techniques that will allow for more powerful programming in current and future browsers.

I'm really pleased to find a modern JavaScript book. It was short, yet I got a lot out of it. On the other hand, there were many errors. I think the editing left something to be desired. Furthermore, it reinforced my belief that the intersection of good JavaScript programmers and really good software engineers is really small. There were many code snippets where too much code was duplicated instead of put into some utility function. There were some utility functions, but a lot of code (for instance, dealing with getting the event and cancelling propogation, which differs among the browsers) was copied all over the place. It was occassionally very frustrating. I wish they had a technical editor who suffered from chronic analness like I do. Nonetheless, it was a pretty good book, and I thank the author for writing it.

The book has a good sense of humor, and a really good sense to tell the meanings of thing in a "readerfrendly" point of view. Some of the topics were known by me before, but after reading it, I discovered much more about them, and learned a new - and in most of the cases - unified way of solving the given problem.
Fantastic book!

Like a lot of the other reviewers, I found the first few chapters the most helpful. If you are willing to completely ignore non-DOM compliant browsers (which we should all be migrating to anyway) then there are some cool techniques that you can learn here.

The only bit I don't like about this book is that you often get yourself into something without really learning much about it. If you've never been exposed to regular expressions before, then you might find it difficult to adapt his cool rollover techniques to other uses... for example using regular expressions to dynamically change the className of a div tag, for example.

Same thing with objects. After he introduces them, he doesn't do to much to explain to you how to use them to your full advantage. He gives you a quick overview and you say to yourself "this is cool stuff", but it would be hard if you've never been exposed to objects in javascript to adapt this knowlege towards other applications within javascript.

The book isn't tremendously long, and so part of the reason for all this might be the target length of the book. Nonetheless, he throws you a bone with a bit of gravy, but if you're trying to find the steak, you're outta luck.

BUT! If you can grasp onto the concepts, then this book is a definate eye opener. I have been able to leverage his examples in many pages at my work thus easing my overall programming burdon. I have found that many of his scripts take a bit of set up to get working, but they all fulfill the promise that after you get them up and running you can geniunely plop them onto any other page and they will work. Pretty cool stuff.

Michael Bodily
Mission Viejo, CA

Overall I like Stuart Langrdige's book "DHTML Utopia Modern Web Design Using JavaScript & DOM". I like the updated examples of how to use Javascript in a modern browser for today's web developer, and I like all the focus on setting up events and the repeated explanation why they are so important/handy. I like these aspects, but while he does some things right, other things are really wrong.

While Mr. Langridge strives to give us modern examples of how to use Javascript in our web pages in the modern day, most of the time it feels like this book is just a whole mash of code examples all squished together. Pictures seem to be relatively few and far between, so instead of reading a great teaching manual/tool, it feels many times more like a reference pamphlet. Now this isn't always a bad thing, but when I pick up a sitepoint book, I expect to find it a bit easier to read (see "The CSS Anthology" by Rachel Andrew) and have it be smoother through the use of more pictures to explain points throughout the learning process.

I feel that "DHTML Utopia" is a worthwhile read for web developers, but I just wished that more pages had been allocated to make the text feel not so squished and more images had been used so that the reader could follow step by step where the author was going, instead of having to keep what we were learning cached in memory, finally getting a picture after turning a # of pages.

All in all, a useful read, but I feel it could have been even better.

**** RECOMMENDED

It make simple to understand how DHTML works; great examples; best buy with Professional JavaScript for Web Developers (Wrox Professional Guides) that handle in deep javascript

This book was excellent in it's coverage of "modern" JavaScript usage. Most JavaScript books try and cover JavaScript from a perspective of HTML 3.2 usage. This book takes us into the modern HTML 4.01 JavaScript usage which most browsers can handle.

It is not a book for someone who doesn't already know JavaScript, but rather for the experienced JavaScript programmer it will teach techniques that may not be well understood.

So I've never been a big fan of JavaScript. I new it had a place in web design but I always left it to those people who really knew JavaScript. Well when I saw this book I decided to pick it up because I haven't been disappointed with any [...] books. after the 1st few chapters I was hooked. I couldn't believe all the cool things I had been missing out. And then when I got into the AJAX portion I was totally sold. If you have any desire to learn or get into JavaScript this is the book to start your library, and don't forget to get the poster (might have to go to sitepoint's web site to get that) it's worth every penny and beautifully done!

Published in May 2005, this is one of the latest books with more up-to-date information on writing accessible scripts using JavaScript, CSS, and the DOM. It even delves into remote scripting, XMLHTTP, AJAX, XML-RPC, XPath, and parsing RSS feeds.

All the code is well documented and can be downloaded from their site, if you know the word to look up in the book.

Browser differences are well-documented, including Safari and Gecko-based browsers.

For older coders, the book details how to move function calls out of HTML elements and into event targets and event listeners, as a better way to handle DOM events.

Also mentioned are techniques such as specifying anonymous functions, using object literals to keep the DHTML encapsulated, coordinating client-side and server-side form validation, enhancing the use of large drop-down lists, timed listeners, delegation.

Some of this was way over my head, but the method of instruction really helped me improve my coding techniques.

There is some great cutting edge stuff in here. If you know what you are doing already and want to get a jump start into Ajax then this is a good book for you. My problem with it is that the text relies too heavily on the code to convey the message. Which means that the book is better for advanced readers. I also would have appreciated some more emphasis on what works cross browser and how to handle older browsers.

There's tons of DHTML books on the market, some dating back several years. However, most are impractical, outdated and lacking in modern best practices (admittingly, this book does stray occasionally from best practices, when it makes sense, and it's fully explained when and why it is done so).

DHTML Utopia's major selling point for me was the focus on cross-browser compatability. Useful interactivity is great to have, but not when it comes at the price of browser compatability. All the examples in the book work flawlessly in IE and Firefox and Safari, and all but a few work in Opera (and when this is the case, the author mentions it).

I also enjoyed the coverage of AJAX/Remote Scripting that this book provided. It's a "hot topic" at the moment, and it was great to see it explaiend in such clear and practical terms in a printed book.

It's refreshing to finally see similar books hitting the market. There is a strong need to cover a modern approach to JavaScript programming, many old hacks aren't required anymore and this book showcase a good amount of up to date techniques. The whole book is 100% practical oriented and assume previous experience with client-side webdeveloping. Organization among the chapters is somewhat lacking but the examples are usually quite easy to follow. I especially appreciated how the author try to follow standards as much as possible, but he keeps a pragmatic attitude when the need arise.

I ran across an interesting title on web programming the other day... DHTML Utopia: Modern Web Design Using JavaScript & DOM by Stuart Langridge (Sitepoint). If you already understand JavaScript, CSS, and HTML, along with the concept of the document object model (DOM), this book might give you some pretty good ideas...

Chapter List: Introduction; DHTML Technologies; The Document Object Model; Handling DOM Events; Detecting Browser Features; Animation; Forms and Validation; Advanced Concepts and Menus; Remote Scripting; Communicating With The Server; Dom Alternatives - XPath; Index

The main intent of this book is to show the reader how DHTML can be used to add a degree of dynamic interaction not often seen in average web pages and applications. Because the book is not overly large (slightly over 300 pages), there is an assumption that you're already familiar with JavaScript, CSS, and HTML. These technologies make up a large part of what's known as DHTML. The other piece is the document object model. Using JavaScript to manipulate the page structure when events occur, you can make the page do things like add fields, expand and collapse parts of the form, highlight rows and columns of tables, etc. Langridge does what I would consider a review of basic DOM concepts before launching into many, many examples of DHTML you can steal for your pages.

This is one of those books where you "learn by doing". Under no circumstances would I consider this a book I'd use as a reference manual. If you have problems with a script or you don't understand certain language functions, you're basically on your own. The ideas and techniques are relatively easy to follow, and you can easily add the code by typing (or downloading from the website). So if you're comfortable with learning by diving right in, you'll probably have better luck with this book than those who might be trying to gain a comprehensive understanding of every part of DHTML. You'll also like the book if you just want some ideas to explore...

In the past year I have seen some impressive yet close to incomprehensible scripts that show a new direction in JavaScript. We can find syntax and approaches so different from the standard practice most of us implement. Unfortunately, the scripters who have grasped the new techniques have shown little interest in explaining the new approach. Their examples published on the Web have a "show-offy" character that do little to communicate or proselytize.

For that reason, I was eager to study this book since it promised to deal with some of the new approaches, including the syntax. I have learned a lot from the author who early on made pains to keep me running apace. Regretfully, the author seemed to be less and less concerned with keeping me with him as the book progressed. The first 4 chapters were the clearest.

Part of the problem was mine. Since the book did not seem to be organized in a linear fashion, I skipped Ch. 5 on animation. I design Web applications so I associate animation with script kiddies and popup ad makers. Ch. 6, on form validation, was up my alley but following the author was painful because he kept referring to a variable "fV" that was defined with a self-referential, bizarrely nested syntax. Only at the end of the chapter did he mention that Ch. 5 first used this syntax. I had to go back to the previous chapter to get a clue. But only a clue because that chapter never really tried to explain why this extremely unconventional approach was used.

The author early on tries to make the case that his approach is better than the conventional one. I *think* I agree but as the chapters progressed, he made less and less effort to prove anything at all. I was very disappointed in this. I also did not like the odd way the braces in the scripts were handled. Because he did not line them up well, it was difficult to tell when a section of a script began or ended. The author recognized this in some cases by putting in comments:
} /* end 'if' */
} /* end 'for' */
It would have been better to match braces visibly. Yes, code alignment is a matter of taste so I cannot really hold that against him.

Some examples did not work quite as advertised. The type-ahead dropdown script did not work at all in Windows Firefox and worked only erratically in IE.

I liked the way the author oriented his examples to user-centered design. Ultimately, the key to the best implementations of JavaScripting is not the syntactical approach but how the functionality fits into the usability of what you are doing.

You never know what you're getting from Sitepoint. Their 'CSS Utopia' book was one of the worst CSS books ever written (1 star!), and yet their next CSS release was one of the *best* CSS books ever written. Go figure.

Like CSS Utopia, DHTML Utopia had the potential to be a great book. It tackles some cutting-edge JavaScript techniques. The authors promise to show you how to accomplish some real magic, and how to better integrate JavaScript into the DHTML triad of XHTML, CSS, and JavaScript.

I'm tempted to say that the authors blew their creative wad with the marketing text.

The book itself reads like a hastily written, "let's get ours out their first" techie tome. It lacks a clear sense of organization: there's no 'big picture' chapter to lead you into the nitty-gritty. And the writing itself is dry, with painfully forced stabs at humor, and a tendency to veer away from real-world practicality into programming gee-whiz.

The production values are also low. All of the Sitepoint books are self-published, and the lack of budget shows. The paper is thick, the text is sometimes faint, and a couple of pages in my copy were crooked. I do like the spine, though. When you open the book and then put it down, it stays flat and open. I wish all tech books had these kinds of spines.

You can download the first four chapters free from Sitepoint. By all means, do so. Judge for yourself. But be prepared for some spammish e-mail from the Sitepoint guys. Every week or so after you download the sample chapters, you'll get these rather patronizing e-mails asking you how you like the book and why you haven't bought it yet. Around the third e-mail, the tone becomes a bit strident. If you complain, Sitepoint will offer you a small discount off the cover price! (But the book is still cheaper here - don't buy it direct from Sitepoint.)

In theory, I suppose, techies writing techie books makes sense. In reality, though, the result is often an expensive user manual, and every bit as much fun to read. For every Steve Krug or Eric Meyer, there are quite a few 'Sitepoint experts'.